{
public class NullableType : TypeExpr
{
- Expression underlying;
+ TypeExpr underlying;
- public NullableType (Expression underlying, Location l)
+ public NullableType (TypeExpr underlying, Location l)
{
this.underlying = underlying;
loc = l;
protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec)
{
- TypeArguments args = new TypeArguments (loc);
- args.Add (underlying);
-
if (TypeManager.generic_nullable_type == null) {
TypeManager.generic_nullable_type = TypeManager.CoreLookupType (
"System", "Nullable`1", Kind.Struct, true);
}
+ TypeArguments args = new TypeArguments (underlying);
GenericTypeExpr ctype = new GenericTypeExpr (TypeManager.generic_nullable_type, args, loc);
return ctype.ResolveAsTypeTerminal (ec, false);
}
HasValue = has_value_pi.GetGetMethod (false);
Value = value_pi.GetGetMethod (false);
#if MS_COMPATIBLE
- if (UnderlyingType.Module == CodeGen.Module.Builder) {
+ if (UnderlyingType.Module == RootContext.ToplevelTypes.Builder) {
Type o_type = TypeManager.DropGenericTypeArguments (type);
Constructor = TypeBuilder.GetConstructor (type,
TypeManager.GetPredefinedConstructor (o_type, Location.Null, o_type.GetGenericArguments ()));
NullableInfo info;
LocalTemporary temp;
+ readonly bool useDefaultValue;
- protected Unwrap (Expression expr)
+ Unwrap (Expression expr, bool useDefaultValue)
{
this.expr = expr;
this.loc = expr.Location;
+ this.useDefaultValue = useDefaultValue;
+
+ info = new NullableInfo (expr.Type);
+ type = info.UnderlyingType;
+ eclass = expr.eclass;
+ }
+
+ public static Expression Create (Expression expr)
+ {
+ //
+ // Avoid unwraping and wraping of same type
+ //
+ Wrap wrap = expr as Wrap;
+ if (wrap != null)
+ return wrap.Child;
+
+ return Create (expr, false);
}
- public static Unwrap Create (Expression expr, EmitContext ec)
+ public static Unwrap Create (Expression expr, bool useDefaultValue)
{
- return new Unwrap (expr).Resolve (ec) as Unwrap;
+ return new Unwrap (expr, useDefaultValue);
}
public override Expression CreateExpressionTree (EmitContext ec)
{
return expr.CreateExpressionTree (ec);
- }
+ }
public override Expression DoResolve (EmitContext ec)
{
- if (expr == null)
- return null;
-
- info = new NullableInfo (expr.Type);
- type = info.UnderlyingType;
- eclass = expr.eclass;
return this;
}
-
+
public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
{
return DoResolve (ec);
- }
+ }
public override void Emit (EmitContext ec)
{
Store (ec);
- AddressOf (ec, AddressOp.LoadStore);
- ec.ig.EmitCall (OpCodes.Call, info.Value, null);
+ if (useDefaultValue)
+ Invocation.EmitCall (ec, false, this, info.GetValueOrDefault, null, loc);
+ else
+ Invocation.EmitCall (ec, false, this, info.Value, null, loc);
}
public void EmitCheck (EmitContext ec)
{
Store (ec);
- AddressOf (ec, AddressOp.LoadStore);
- ec.ig.EmitCall (OpCodes.Call, info.HasValue, null);
- }
-
- public void EmitGetValueOrDefault (EmitContext ec)
- {
- Store (ec);
- AddressOf (ec, AddressOp.LoadStore);
- ec.ig.EmitCall (OpCodes.Call, info.GetValueOrDefault, null);
+ Invocation.EmitCall (ec, false, this, info.HasValue, null, loc);
}
public override bool Equals (object obj)
eclass = ExprClass.Value;
}
+ public Expression Child {
+ get { return child; }
+ }
+
+ public override Expression CreateExpressionTree (EmitContext ec)
+ {
+ TypeCast child_cast = child as TypeCast;
+ if (child_cast != null) {
+ child.Type = type;
+ return child_cast.CreateExpressionTree (ec);
+ }
+
+ return base.CreateExpressionTree (ec);
+ }
+
public static Expression Create (Expression expr, Type type)
{
//
public override Expression CreateExpressionTree (EmitContext ec)
{
- ArrayList args = new ArrayList (2);
+ Arguments args = new Arguments (2);
args.Add (new Argument (this));
args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
}
}
- public abstract class Lifted : Expression, IMemoryLocation
+ public class Lifted : Expression, IMemoryLocation
{
- Expression expr, underlying, wrap, null_value;
+ Expression expr, wrap, null_value;
Unwrap unwrap;
- protected Lifted (Expression expr, Location loc)
+ public Lifted (Expression expr, Unwrap unwrap, Type type)
{
this.expr = expr;
- this.loc = loc;
+ this.unwrap = unwrap;
+ this.loc = expr.Location;
+ this.type = type;
+ }
+
+ public Lifted (Expression expr, Expression unwrap, Type type)
+ : this (expr, unwrap as Unwrap, type)
+ {
}
public override Expression CreateExpressionTree (EmitContext ec)
{
- ArrayList args = new ArrayList (2);
- args.Add (new Argument (expr.CreateExpressionTree (ec)));
- args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
- return CreateExpressionFactoryCall ("Convert", args);
+ return wrap.CreateExpressionTree (ec);
}
public override Expression DoResolve (EmitContext ec)
{
- expr = expr.Resolve (ec);
- if (expr == null)
+ wrap = Wrap.Create (expr, type);
+ if (wrap == null)
return null;
- unwrap = Unwrap.Create (expr, ec);
+ //
+ // It's null when lifted conversion is transparent
+ //
if (unwrap == null)
- return null;
-
- underlying = ResolveUnderlying (unwrap, ec);
- if (underlying == null)
- return null;
+ return wrap;
- TypeExpr target_type = new NullableType (underlying.Type, loc);
- target_type = target_type.ResolveAsTypeTerminal (ec, false);
- if (target_type == null)
- return null;
-
- wrap = Wrap.Create (underlying, target_type.Type);
- if (wrap == null)
- return null;
-
- null_value = LiftedNull.Create (wrap.Type, loc);
+ null_value = LiftedNull.Create (type, loc);
- type = wrap.Type;
eclass = ExprClass.Value;
return this;
}
- protected abstract Expression ResolveUnderlying (Expression unwrap, EmitContext ec);
-
public override void Emit (EmitContext ec)
{
ILGenerator ig = ec.ig;
}
}
- public class LiftedConversion : Lifted
- {
- public readonly bool IsUser;
- public readonly bool IsExplicit;
- public readonly Type TargetType;
-
- public LiftedConversion (Expression expr, Type target_type, bool is_user,
- bool is_explicit, Location loc)
- : base (expr, loc)
- {
- this.IsUser = is_user;
- this.IsExplicit = is_explicit;
- this.TargetType = target_type;
- }
-
- protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
- {
- Type type = TypeManager.GetTypeArguments (TargetType) [0];
-
- if (IsUser) {
- if (IsExplicit)
- return Convert.ExplicitUserConversion (ec, unwrap, type, loc);
- else
- return Convert.ImplicitUserConversion (ec, unwrap, type, loc);
- } else {
- if (IsExplicit)
- return Convert.ExplicitConversion (ec, unwrap, type, loc);
- else
- return Convert.ImplicitConversion (ec, unwrap, type, loc);
- }
- }
- }
-
public class LiftedUnaryOperator : Unary, IMemoryLocation
{
Unwrap unwrap;
if (eclass != ExprClass.Invalid)
return this;
- unwrap = Unwrap.Create (Expr, ec);
+ unwrap = Unwrap.Create (Expr, false);
if (unwrap == null)
return null;
return null;
}
+ bool use_default_call = (Oper & (Operator.BitwiseMask | Operator.EqualityMask)) != 0;
left_orig = left;
if (TypeManager.IsNullableType (left.Type)) {
- left = left_unwrap = Unwrap.Create (left, ec);
+ left = left_unwrap = Unwrap.Create (left, use_default_call);
if (left == null)
return null;
}
right_orig = right;
if (TypeManager.IsNullableType (right.Type)) {
- right = right_unwrap = Unwrap.Create (right, ec);
+ right = right_unwrap = Unwrap.Create (right, use_default_call);
if (right == null)
return null;
}
// Arguments can be lifted for equal operators when the return type is bool and both
// arguments are of same type
//
- if (left is NullLiteral) {
+ if (left_orig.IsNull) {
left = right;
left_null_lifted = true;
type = TypeManager.bool_type;
}
- if (right is NullLiteral) {
+ if (right_orig.IsNull) {
right = left;
right_null_lifted = true;
type = TypeManager.bool_type;
Label load_right = ig.DefineLabel ();
Label end_label = ig.DefineLabel ();
- left_unwrap.EmitGetValueOrDefault (ec);
+ left_unwrap.Emit (ec);
ig.Emit (OpCodes.Brtrue_S, load_right);
- right_unwrap.EmitGetValueOrDefault (ec);
+ right_unwrap.Emit (ec);
ig.Emit (OpCodes.Brtrue_S, load_left);
left_unwrap.EmitCheck (ec);
//
// Emits optimized equality or inequality operator when possible
//
- bool EmitEquality (EmitContext ec)
+ void EmitEquality (EmitContext ec)
{
ILGenerator ig = ec.ig;
ig.Emit (OpCodes.Ldc_I4_0);
ig.Emit (OpCodes.Ceq);
}
- return true;
+ return;
}
if (right_unwrap != null && (left_null_lifted || left.IsNull)) {
ig.Emit (OpCodes.Ldc_I4_0);
ig.Emit (OpCodes.Ceq);
}
- return true;
+ return;
}
- if (user_operator != null)
- return false;
-
Label dissimilar_label = ig.DefineLabel ();
Label end_label = ig.DefineLabel ();
- if (left_unwrap != null)
- left_unwrap.EmitGetValueOrDefault (ec);
- else
+ if (user_operator != null) {
+ user_operator.Emit (ec);
+ ig.Emit (Oper == Operator.Equality ? OpCodes.Brfalse_S : OpCodes.Brtrue_S, dissimilar_label);
+ } else {
left.Emit (ec);
-
- if (right_unwrap != null)
- right_unwrap.EmitGetValueOrDefault (ec);
- else
right.Emit (ec);
- ig.Emit (OpCodes.Bne_Un_S, dissimilar_label);
+ ig.Emit (OpCodes.Bne_Un_S, dissimilar_label);
+ }
if (left_unwrap != null)
left_unwrap.EmitCheck (ec);
+
if (right_unwrap != null)
right_unwrap.EmitCheck (ec);
ig.Emit (OpCodes.Ldc_I4_0);
ig.MarkLabel (end_label);
- return true;
}
public override void EmitBranchable (EmitContext ec, Label target, bool onTrue)
}
if ((Oper & Operator.EqualityMask) != 0) {
- if (EmitEquality (ec))
- return;
+ EmitEquality (ec);
+ return;
}
ILGenerator ig = ec.ig;
ig.MarkLabel (is_null_label);
if ((Oper & Operator.ComparisonMask) != 0) {
- //
- // Emit true when equality operator both operands are null
- // or inequality operator operands has only one null
- //
- if ((Oper == Operator.Equality && left_unwrap != null && right_unwrap != null) ||
- (Oper == Operator.Inequality && left_unwrap != right_unwrap))
- ig.Emit (OpCodes.Ldc_I4_1);
- else
- ig.Emit (OpCodes.Ldc_I4_0);
+ ig.Emit (OpCodes.Ldc_I4_0);
} else {
LiftedNull.Create (type, loc).Emit (ec);
}
public override Expression CreateExpressionTree (EmitContext ec)
{
- if (left is NullLiteral)
+ if (left.Type == TypeManager.null_type)
Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side");
UserCast uc = left as UserCast;
if (uc != null) {
left = uc.Source;
- ArrayList c_args = new ArrayList (2);
+ Arguments c_args = new Arguments (2);
c_args.Add (new Argument (uc.CreateExpressionTree (ec)));
c_args.Add (new Argument (left.CreateExpressionTree (ec)));
conversion = CreateExpressionFactoryCall ("Lambda", c_args);
}
- ArrayList args = new ArrayList (3);
+ Arguments args = new Arguments (3);
args.Add (new Argument (left.CreateExpressionTree (ec)));
args.Add (new Argument (right.CreateExpressionTree (ec)));
if (conversion != null)
// the result is underlying type of left
//
if (TypeManager.IsNullableType (ltype)) {
- unwrap = Unwrap.Create (left, ec);
+ unwrap = Unwrap.Create (left, false);
if (unwrap == null)
return null;
if (expr == null)
return null;
- unwrap = Unwrap.Create (expr, ec);
+ unwrap = Unwrap.Create (expr, false);
if (unwrap == null)
return null;
projects / mono.git / blobdiff