: this (new TypeExpression (type, loc), loc)
{ }
- protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec)
+ protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
{
if (TypeManager.generic_nullable_type == null) {
- TypeManager.generic_nullable_type = TypeManager.CoreLookupType (
+ TypeManager.generic_nullable_type = TypeManager.CoreLookupType (ec.Compiler,
"System", "Nullable`1", Kind.Struct, true);
}
return ctype.ResolveAsTypeTerminal (ec, false);
}
- public override TypeExpr ResolveAsTypeTerminal (IResolveContext ec, bool silent)
+ public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent)
{
return ResolveAsBaseTerminal (ec, silent);
}
HasValue = has_value_pi.GetGetMethod (false);
Value = value_pi.GetGetMethod (false);
+
+ // When compiling corlib
+ if (TypeManager.IsBeingCompiled (type)) {
+ TypeContainer tc = TypeManager.LookupGenericTypeContainer (type);
+
+ // TODO: check for correct overload
+ Constructor c = ((Constructor) tc.InstanceConstructors [0]);
+
+ Constructor = TypeBuilder.GetConstructor (type, c.ConstructorBuilder);
+ return;
+ }
+
#if MS_COMPATIBLE
- 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 ()));
+ if (TypeManager.IsBeingCompiled (UnderlyingType)) {
+ ConstructorInfo cinfo = TypeManager.DropGenericTypeArguments (type).GetConstructors ()[0];
+ Constructor = TypeBuilder.GetConstructor (type, cinfo);
return;
}
#endif
+
Constructor = type.GetConstructor (new Type[] { UnderlyingType });
}
}
return new Unwrap (expr, useDefaultValue);
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
return expr.CreateExpressionTree (ec);
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
return this;
}
- public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
+ public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
{
return DoResolve (ec);
}
LocalVariable.Emit (ec);
}
+#if NET_4_0
+ public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
+ {
+ return expr.MakeExpression (ctx);
+ }
+#endif
+
public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
{
type = storey.MutateType (type);
eclass = ExprClass.Value;
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
throw new NotSupportedException ("ET");
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
return this;
}
get { return child; }
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
TypeCast child_cast = child as TypeCast;
if (child_cast != null) {
//
// Represents null literal lifted to nullable type
//
- public class LiftedNull : EmptyConstantCast, IMemoryLocation
+ public class LiftedNull : NullConstant, IMemoryLocation
{
private LiftedNull (Type nullable_type, Location loc)
- : base (new NullLiteral (loc), nullable_type)
+ : base (nullable_type, loc)
{
eclass = ExprClass.Value;
}
return new LiftedNull (nullable, loc);
}
- public static Expression CreateFromExpression (Expression e)
+ public static Expression CreateFromExpression (ResolveContext ec, Expression e)
{
- Report.Warning (458, 2, e.Location, "The result of the expression is always `null' of type `{0}'",
+ ec.Report.Warning (458, 2, e.Location, "The result of the expression is always `null' of type `{0}'",
TypeManager.CSharpName (e.Type));
return ReducedExpression.Create (Create (e.Type, e.Location), e);
}
- public override Expression CreateExpressionTree (EmitContext ec)
- {
- Arguments args = new Arguments (2);
- args.Add (new Argument (this));
- args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
-
- return CreateExpressionFactoryCall ("Constant", args);
- }
-
public override void Emit (EmitContext ec)
{
// TODO: generate less temporary variables
}
}
+ //
+ // Generic lifting expression, supports all S/S? -> T/T? cases
+ //
public class Lifted : Expression, IMemoryLocation
{
- Expression expr, wrap, null_value;
+ Expression expr, null_value;
Unwrap unwrap;
public Lifted (Expression expr, Unwrap unwrap, Type type)
{
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
- return wrap.CreateExpressionTree (ec);
+ return expr.CreateExpressionTree (ec);
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
- wrap = Wrap.Create (expr, type);
- if (wrap == null)
- return null;
-
//
- // It's null when lifted conversion is transparent
+ // It's null when lifting non-nullable type
//
- if (unwrap == null)
- return wrap;
+ if (unwrap == null) {
+ // S -> T? is wrap only
+ if (TypeManager.IsNullableType (type))
+ return Wrap.Create (expr, type);
+
+ // S -> T can be simplified
+ return expr;
+ }
+
+ // Wrap target for T?
+ if (TypeManager.IsNullableType (type)) {
+ expr = Wrap.Create (expr, type);
+ if (expr == null)
+ return null;
- null_value = LiftedNull.Create (type, loc);
+ null_value = LiftedNull.Create (type, loc);
+ } else {
+ null_value = new NullConstant (type, loc);
+ }
eclass = ExprClass.Value;
return this;
unwrap.EmitCheck (ec);
ig.Emit (OpCodes.Brfalse, is_null_label);
- wrap.Emit (ec);
- ig.Emit (OpCodes.Br, end_label);
+ expr.Emit (ec);
+ ig.Emit (OpCodes.Br, end_label);
ig.MarkLabel (is_null_label);
- null_value.Emit (ec);
+ null_value.Emit (ec);
ig.MarkLabel (end_label);
}
unwrap.AddressOf (ec, mode);
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
if (user_operator != null)
return user_operator.CreateExpressionTree (ec);
return base.CreateExpressionTree (ec);
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
if (eclass != ExprClass.Invalid)
return this;
ig.MarkLabel (end_label);
}
- Expression LiftExpression (EmitContext ec, Expression expr)
+ Expression LiftExpression (ResolveContext ec, Expression expr)
{
TypeExpr lifted_type = new NullableType (expr.Type, expr.Location);
lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
return expr;
}
- protected override Expression ResolveEnumOperator (EmitContext ec, Expression expr)
+ protected override Expression ResolveEnumOperator (ResolveContext ec, Expression expr)
{
expr = base.ResolveEnumOperator (ec, expr);
if (expr == null)
return LiftExpression (ec, expr);
}
- protected override Expression ResolveUserOperator (EmitContext ec, Expression expr)
+ protected override Expression ResolveUserOperator (ResolveContext ec, Expression expr)
{
expr = base.ResolveUserOperator (ec, expr);
if (expr == null)
this.loc = loc;
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
if (user_operator != null)
return user_operator.CreateExpressionTree (ec);
// with the null literal *outside* of a generics context and
// inlines that as true or false.
//
- Expression CreateNullConstant (Expression expr)
+ Expression CreateNullConstant (ResolveContext ec, Expression expr)
{
// FIXME: Handle side effect constants
Constant c = new BoolConstant (Oper == Operator.Inequality, loc);
if ((Oper & Operator.EqualityMask) != 0) {
- Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is `{1}'",
- expr.GetSignatureForError (), c.AsString ());
+ ec.Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is `{1}'",
+ TypeManager.CSharpName (expr.Type), c.AsString ());
} else {
- Report.Warning (464, 2, loc, "The result of comparing type `{0}' with null is always `{1}'",
- expr.GetSignatureForError (), c.AsString ());
+ ec.Report.Warning (464, 2, loc, "The result of comparing type `{0}' with null is always `{1}'",
+ TypeManager.CSharpName (expr.Type), c.AsString ());
}
return ReducedExpression.Create (c, this);
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
if (eclass != ExprClass.Invalid)
return this;
if ((Oper & Operator.LogicalMask) != 0) {
- Error_OperatorCannotBeApplied (left, right);
+ Error_OperatorCannotBeApplied (ec, left, right);
return null;
}
}
}
- Expression LiftResult (EmitContext ec, Expression res_expr)
+ Expression LiftResult (ResolveContext ec, Expression res_expr)
{
TypeExpr lifted_type;
if (left_null_lifted) {
left = LiftedNull.Create (right.Type, left.Location);
- if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask)) != 0)
- return LiftedNull.CreateFromExpression (res_expr);
+ if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0)
+ return LiftedNull.CreateFromExpression (ec, res_expr);
//
// Value types and null comparison
//
if (right_unwrap == null || (Oper & Operator.RelationalMask) != 0)
- return CreateNullConstant (right_orig).Resolve (ec);
+ return CreateNullConstant (ec, right_orig).Resolve (ec);
}
if (right_null_lifted) {
right = LiftedNull.Create (left.Type, right.Location);
- if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask)) != 0)
- return LiftedNull.CreateFromExpression (res_expr);
+ if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0)
+ return LiftedNull.CreateFromExpression (ec, res_expr);
//
// Value types and null comparison
//
if (left_unwrap == null || (Oper & Operator.RelationalMask) != 0)
- return CreateNullConstant (left_orig).Resolve (ec);
+ return CreateNullConstant (ec, left_orig).Resolve (ec);
}
return res_expr;
}
- protected override Expression ResolveOperatorPredefined (EmitContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, Type enum_type)
+ protected override Expression ResolveOperatorPredefined (ResolveContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, Type enum_type)
{
Expression e = base.ResolveOperatorPredefined (ec, operators, primitives_only, enum_type);
return e;
}
- protected override Expression ResolveUserOperator (EmitContext ec, Type l, Type r)
+ protected override Expression ResolveUserOperator (ResolveContext ec, Type l, Type r)
{
Expression expr = base.ResolveUserOperator (ec, l, r);
if (expr == null)
this.loc = loc;
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
if (left.Type == TypeManager.null_type)
- Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side");
+ ec.Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side");
UserCast uc = left as UserCast;
Expression conversion = null;
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);
+ conversion = CreateExpressionFactoryCall (ec, "Lambda", c_args);
}
Arguments args = new Arguments (3);
if (conversion != null)
args.Add (new Argument (conversion));
- return CreateExpressionFactoryCall ("Coalesce", args);
+ return CreateExpressionFactoryCall (ec, "Coalesce", args);
}
- Expression ConvertExpression (EmitContext ec)
+ Expression ConvertExpression (ResolveContext ec)
{
// TODO: ImplicitConversionExists should take care of this
if (left.eclass == ExprClass.MethodGroup)
return this;
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
if (eclass != ExprClass.Invalid)
return this;
Expression e = ConvertExpression (ec);
if (e == null) {
- Binary.Error_OperatorCannotBeApplied (left, right, "??", loc);
+ Binary.Error_OperatorCannotBeApplied (ec, left, right, "??", loc);
return null;
}
eclass = ExprClass.Value;
}
- public override Expression CreateExpressionTree (EmitContext ec)
+ public override Expression CreateExpressionTree (ResolveContext ec)
{
return new SimpleAssign (this, this).CreateExpressionTree (ec);
}
- public override Expression DoResolve (EmitContext ec)
+ public override Expression DoResolve (ResolveContext ec)
{
expr = expr.Resolve (ec);
if (expr == null)
projects / mono.git / blobdiff