//
// ecore.cs: Core of the Expression representation for the intermediate tree.
//
// Author:
//   Miguel de Icaza (miguel@ximian.com)
//   Marek Safar (marek.safar@gmail.com)
//
// Copyright 2001, 2002, 2003 Ximian, Inc.
// Copyright 2003-2008 Novell, Inc.
// Copyright 2011-2012 Xamarin Inc.
//
//

using System;
using System.Collections.Generic;
using System.Text;
using SLE = System.Linq.Expressions;
using System.Linq;

#if STATIC
using IKVM.Reflection;
using IKVM.Reflection.Emit;
#else
using System.Reflection;
using System.Reflection.Emit;
#endif

namespace Mono.CSharp {

	/// <remarks>
	///   The ExprClass class contains the is used to pass the 
	///   classification of an expression (value, variable, namespace,
	///   type, method group, property access, event access, indexer access,
	///   nothing).
	/// </remarks>
	public enum ExprClass : byte {
		Unresolved	= 0,
		
		Value,
		Variable,
		Namespace,
		Type,
		TypeParameter,
		MethodGroup,
		PropertyAccess,
		EventAccess,
		IndexerAccess,
		Nothing, 
	}

	/// <remarks>
	///   This is used to tell Resolve in which types of expressions we're
	///   interested.
	/// </remarks>
	[Flags]
	public enum ResolveFlags {
		// Returns Value, Variable, PropertyAccess, EventAccess or IndexerAccess.
		VariableOrValue		= 1,

		// Returns a type expression.
		Type			= 1 << 1,

		// Returns a method group.
		MethodGroup		= 1 << 2,

		TypeParameter	= 1 << 3,

		// Mask of all the expression class flags.
		MaskExprClass = VariableOrValue | Type | MethodGroup | TypeParameter,
	}

	//
	// This is just as a hint to AddressOf of what will be done with the
	// address.
	[Flags]
	public enum AddressOp {
		Store = 1,
		Load  = 2,
		LoadStore = 3
	};
	
	/// <summary>
	///   This interface is implemented by variables
	/// </summary>
	public interface IMemoryLocation {
		/// <summary>
		///   The AddressOf method should generate code that loads
		///   the address of the object and leaves it on the stack.
		///
		///   The `mode' argument is used to notify the expression
		///   of whether this will be used to read from the address or
		///   write to the address.
		///
		///   This is just a hint that can be used to provide good error
		///   reporting, and should have no other side effects. 
		/// </summary>
		void AddressOf (EmitContext ec, AddressOp mode);
	}

	//
	// An expressions resolved as a direct variable reference
	//
	public interface IVariableReference : IFixedExpression
	{
		bool IsHoisted { get; }
		string Name { get; }
		VariableInfo VariableInfo { get; }

		void SetHasAddressTaken ();
	}

	//
	// Implemented by an expression which could be or is always
	// fixed
	//
	public interface IFixedExpression
	{
		bool IsFixed { get; }
	}

	public interface IExpressionCleanup
	{
		void EmitCleanup (EmitContext ec);
	}

	/// <remarks>
	///   Base class for expressions
	/// </remarks>
	public abstract class Expression {
		public ExprClass eclass;
		protected TypeSpec type;
		protected Location loc;
		
		public TypeSpec Type {
			get { return type; }
			set { type = value; }
		}

		public virtual bool IsSideEffectFree {
			get {
				return false;
			}
		}

		public Location Location {
			get { return loc; }
		}

		public virtual bool IsNull {
			get {
				return false;
			}
		}

		//
		// Used to workaround parser limitation where we cannot get
		// start of statement expression location
		//
		public virtual Location StartLocation {
			get {
				return loc;
			}
		}

		public virtual MethodGroupExpr CanReduceLambda (AnonymousMethodBody body)
		{
			//
			// Return method-group expression when the expression can be used as
			// lambda replacement. A good example is array sorting where instead of
			// code like
			//
			//  Array.Sort (s, (a, b) => String.Compare (a, b));
			//
			// we can use method group directly
			//
			//  Array.Sort (s, String.Compare);
			//
			// Correct overload will be used because we do the reduction after
			// best candidate was found.
			//
			return null;
		}

		//
		// Returns true when the expression during Emit phase breaks stack
		// by using await expression
		//
		public virtual bool ContainsEmitWithAwait ()
		{
			return false;
		}

		/// <summary>
		///   Performs semantic analysis on the Expression
		/// </summary>
		///
		/// <remarks>
		///   The Resolve method is invoked to perform the semantic analysis
		///   on the node.
		///
		///   The return value is an expression (it can be the
		///   same expression in some cases) or a new
		///   expression that better represents this node.
		///   
		///   For example, optimizations of Unary (LiteralInt)
		///   would return a new LiteralInt with a negated
		///   value.
		///   
		///   If there is an error during semantic analysis,
		///   then an error should be reported (using Report)
		///   and a null value should be returned.
		///   
		///   There are two side effects expected from calling
		///   Resolve(): the the field variable "eclass" should
		///   be set to any value of the enumeration
		///   `ExprClass' and the type variable should be set
		///   to a valid type (this is the type of the
		///   expression).
		/// </remarks>
		protected abstract Expression DoResolve (ResolveContext rc);

		public virtual Expression DoResolveLValue (ResolveContext rc, Expression right_side)
		{
			return null;
		}

		//
		// This is used if the expression should be resolved as a type or namespace name.
		// the default implementation fails.   
		//
		public virtual TypeSpec ResolveAsType (IMemberContext mc, bool allowUnboundTypeArguments = false)
		{
			ResolveContext ec = new ResolveContext (mc);
			Expression e = Resolve (ec);
			if (e != null)
				e.Error_UnexpectedKind (ec, ResolveFlags.Type, loc);

			return null;
		}

		public static void ErrorIsInaccesible (IMemberContext rc, string member, Location loc)
		{
			rc.Module.Compiler.Report.Error (122, loc, "`{0}' is inaccessible due to its protection level", member);
		}

		public void Error_ExpressionMustBeConstant (ResolveContext rc, Location loc, string e_name)
		{
			rc.Report.Error (133, loc, "The expression being assigned to `{0}' must be constant", e_name);
		}

		public void Error_ConstantCanBeInitializedWithNullOnly (ResolveContext rc, TypeSpec type, Location loc, string name)
		{
			rc.Report.Error (134, loc, "A constant `{0}' of reference type `{1}' can only be initialized with null",
				name, type.GetSignatureForError ());
		}

		protected virtual void Error_InvalidExpressionStatement (Report report, Location loc)
		{
			report.Error (201, loc, "Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement");
		}
		
		public void Error_InvalidExpressionStatement (BlockContext bc)
		{
			Error_InvalidExpressionStatement (bc.Report, loc);
		}

		public void Error_InvalidExpressionStatement (Report report)
		{
			Error_InvalidExpressionStatement (report, loc);
		}

		public static void Error_VoidInvalidInTheContext (Location loc, Report Report)
		{
			Report.Error (1547, loc, "Keyword `void' cannot be used in this context");
		}

		public virtual void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec target, bool expl)
		{
			Error_ValueCannotBeConvertedCore (ec, loc, target, expl);
		}

		protected void Error_ValueCannotBeConvertedCore (ResolveContext ec, Location loc, TypeSpec target, bool expl)
		{
			// The error was already reported as CS1660
			if (type == InternalType.AnonymousMethod)
				return;

			if (type == InternalType.ErrorType || target == InternalType.ErrorType)
				return;

			string from_type = type.GetSignatureForError ();
			string to_type = target.GetSignatureForError ();
			if (from_type == to_type) {
				from_type = type.GetSignatureForErrorIncludingAssemblyName ();
				to_type = target.GetSignatureForErrorIncludingAssemblyName ();
			}

			if (expl) {
				ec.Report.Error (30, loc, "Cannot convert type `{0}' to `{1}'",
					from_type, to_type);
				return;
			}

			ec.Report.DisableReporting ();
			bool expl_exists = Convert.ExplicitConversion (ec, this, target, Location.Null) != null;
			ec.Report.EnableReporting ();

			if (expl_exists) {
				ec.Report.Error (266, loc,
					"Cannot implicitly convert type `{0}' to `{1}'. An explicit conversion exists (are you missing a cast?)",
					from_type, to_type);
			} else {
				ec.Report.Error (29, loc, "Cannot implicitly convert type `{0}' to `{1}'",
					from_type, to_type);
			}
		}

		public void Error_TypeArgumentsCannotBeUsed (IMemberContext context, MemberSpec member, Location loc)
		{
			// Better message for possible generic expressions
			if (member != null && (member.Kind & MemberKind.GenericMask) != 0) {
				var report = context.Module.Compiler.Report;
				report.SymbolRelatedToPreviousError (member);
				if (member is TypeSpec)
					member = ((TypeSpec) member).GetDefinition ();
				else
					member = ((MethodSpec) member).GetGenericMethodDefinition ();

				string name = member.Kind == MemberKind.Method ? "method" : "type";
				if (member.IsGeneric) {
					report.Error (305, loc, "Using the generic {0} `{1}' requires `{2}' type argument(s)",
						name, member.GetSignatureForError (), member.Arity.ToString ());
				} else {
					report.Error (308, loc, "The non-generic {0} `{1}' cannot be used with the type arguments",
						name, member.GetSignatureForError ());
				}
			} else {
				Error_TypeArgumentsCannotBeUsed (context, ExprClassName, GetSignatureForError (), loc);
			}
		}

		public static void Error_TypeArgumentsCannotBeUsed (IMemberContext context, string exprType, string name, Location loc)
		{
			context.Module.Compiler.Report.Error (307, loc, "The {0} `{1}' cannot be used with type arguments",
				exprType, name);
		}

		protected virtual void Error_TypeDoesNotContainDefinition (ResolveContext ec, TypeSpec type, string name)
		{
			Error_TypeDoesNotContainDefinition (ec, loc, type, name);
		}

		public static void Error_TypeDoesNotContainDefinition (ResolveContext ec, Location loc, TypeSpec type, string name)
		{
			ec.Report.SymbolRelatedToPreviousError (type);
			ec.Report.Error (117, loc, "`{0}' does not contain a definition for `{1}'",
				type.GetSignatureForError (), name);
		}

		public virtual void Error_ValueAssignment (ResolveContext rc, Expression rhs)
		{
			if (rhs == EmptyExpression.LValueMemberAccess || rhs == EmptyExpression.LValueMemberOutAccess) {
				// Already reported as CS1612
			} else if (rhs == EmptyExpression.OutAccess) {
				rc.Report.Error (1510, loc, "A ref or out argument must be an assignable variable");
			} else {
				rc.Report.Error (131, loc, "The left-hand side of an assignment must be a variable, a property or an indexer");
			}
		}

		protected void Error_VoidPointerOperation (ResolveContext rc)
		{
			rc.Report.Error (242, loc, "The operation in question is undefined on void pointers");
		}

		public static void Warning_UnreachableExpression (ResolveContext rc, Location loc)
		{
			rc.Report.Warning (429, 4, loc, "Unreachable expression code detected");
		}

		public ResolveFlags ExprClassToResolveFlags {
			get {
				switch (eclass) {
				case ExprClass.Type:
				case ExprClass.Namespace:
					return ResolveFlags.Type;
					
				case ExprClass.MethodGroup:
					return ResolveFlags.MethodGroup;
					
				case ExprClass.TypeParameter:
					return ResolveFlags.TypeParameter;
					
				case ExprClass.Value:
				case ExprClass.Variable:
				case ExprClass.PropertyAccess:
				case ExprClass.EventAccess:
				case ExprClass.IndexerAccess:
					return ResolveFlags.VariableOrValue;
					
				default:
					throw new InternalErrorException (loc.ToString () + " " +  GetType () + " ExprClass is Invalid after resolve");
				}
			}
		}

		//
		// Implements identical simple name and type-name resolution
		//
		public Expression ProbeIdenticalTypeName (ResolveContext rc, Expression left, SimpleName name)
		{
			var t = left.Type;
			if (t.Kind == MemberKind.InternalCompilerType || t is ElementTypeSpec || t.Arity > 0)
				return left;

			// In a member access of the form E.I, if E is a single identifier, and if the meaning of E as a simple-name is
			// a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type-name

			if (left is MemberExpr || left is VariableReference) {
				var identical_type = rc.LookupNamespaceOrType (name.Name, 0, LookupMode.Probing, loc) as TypeExpr;
				if (identical_type != null && identical_type.Type == left.Type)
					return identical_type;
			}

			return left;
		}

		public virtual string GetSignatureForError ()
		{
			return type.GetDefinition ().GetSignatureForError ();
		}

		public static bool IsNeverNull (Expression expr)
		{
			if (expr is This || expr is New || expr is ArrayCreation || expr is DelegateCreation || expr is ConditionalMemberAccess)
				return true;

			var c = expr as Constant;
			if (c != null)
				return !c.IsNull;

			var tc = expr as TypeCast;
			if (tc != null)
				return IsNeverNull (tc.Child);

			return false;
		}

		protected static bool IsNullPropagatingValid (TypeSpec type)
		{
			switch (type.Kind) {
			case MemberKind.Struct:
				return type.IsNullableType;
			case MemberKind.Enum:
			case MemberKind.Void:
			case MemberKind.PointerType:
				return false;
			case MemberKind.InternalCompilerType:
				return type.BuiltinType == BuiltinTypeSpec.Type.Dynamic;
			default:
				return true;
			}
		}

		public virtual bool HasConditionalAccess ()
		{
			return false;
		}

		protected static TypeSpec LiftMemberType (ResolveContext rc, TypeSpec type)
		{
			return TypeSpec.IsValueType (type) && !type.IsNullableType ?
				Nullable.NullableInfo.MakeType (rc.Module, type) :
				type;
		}
	       
		/// <summary>
		///   Resolves an expression and performs semantic analysis on it.
		/// </summary>
		///
		/// <remarks>
		///   Currently Resolve wraps DoResolve to perform sanity
		///   checking and assertion checking on what we expect from Resolve.
		/// </remarks>
		public Expression Resolve (ResolveContext ec, ResolveFlags flags)
		{
			if (eclass != ExprClass.Unresolved) {
				if ((flags & ExprClassToResolveFlags) == 0) {
					Error_UnexpectedKind (ec, flags, loc);
					return null;
				}

				return this;
			}
			
			Expression e;
			try {
				e = DoResolve (ec);

				if (e == null)
					return null;

				if ((flags & e.ExprClassToResolveFlags) == 0) {
					e.Error_UnexpectedKind (ec, flags, loc);
					return null;
				}

				if (e.type == null)
					throw new InternalErrorException ("Expression `{0}' didn't set its type in DoResolve", e.GetType ());

				return e;
			} catch (Exception ex) {
				if (loc.IsNull || ec.Module.Compiler.Settings.BreakOnInternalError || ex is CompletionResult || ec.Report.IsDisabled || ex is FatalException ||
					ec.Report.Printer is NullReportPrinter)
					throw;

				ec.Report.Error (584, loc, "Internal compiler error: {0}", ex.Message);
				return ErrorExpression.Instance;	// TODO: Add location
			}
		}

		/// <summary>
		///   Resolves an expression and performs semantic analysis on it.
		/// </summary>
		public Expression Resolve (ResolveContext rc)
		{
			return Resolve (rc, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
		}

		/// <summary>
		///   Resolves an expression for LValue assignment
		/// </summary>
		///
		/// <remarks>
		///   Currently ResolveLValue wraps DoResolveLValue to perform sanity
		///   checking and assertion checking on what we expect from Resolve
		/// </remarks>
		public Expression ResolveLValue (ResolveContext ec, Expression right_side)
		{
			int errors = ec.Report.Errors;
			bool out_access = right_side == EmptyExpression.OutAccess;

			Expression e = DoResolveLValue (ec, right_side);

			if (e != null && out_access && !(e is IMemoryLocation)) {
				// FIXME: There's no problem with correctness, the 'Expr = null' handles that.
				//        Enabling this 'throw' will "only" result in deleting useless code elsewhere,

				//throw new InternalErrorException ("ResolveLValue didn't return an IMemoryLocation: " +
				//				  e.GetType () + " " + e.GetSignatureForError ());
				e = null;
			}

			if (e == null) {
				if (errors == ec.Report.Errors) {
					Error_ValueAssignment (ec, right_side);
				}
				return null;
			}

			if (e.eclass == ExprClass.Unresolved)
				throw new Exception ("Expression " + e + " ExprClass is Invalid after resolve");

			if ((e.type == null) && !(e is GenericTypeExpr))
				throw new Exception ("Expression " + e + " did not set its type after Resolve");

			return e;
		}

		public Constant ResolveLabelConstant (ResolveContext rc)
		{
			var expr = Resolve (rc);
			if (expr == null)
				return null;

			Constant c = expr as Constant;
			if (c == null) {
				if (expr.type != InternalType.ErrorType)
					rc.Report.Error (150, expr.StartLocation, "A constant value is expected");

				return null;
			}

			return c;
		}

		public virtual void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
		{
			if (Attribute.IsValidArgumentType (parameterType)) {
				rc.Module.Compiler.Report.Error (182, loc,
					"An attribute argument must be a constant expression, typeof expression or array creation expression");
			} else {
				rc.Module.Compiler.Report.Error (181, loc,
					"Attribute constructor parameter has type `{0}', which is not a valid attribute parameter type",
					targetType.GetSignatureForError ());
			}
		}

		/// <summary>
		///   Emits the code for the expression
		/// </summary>
		///
		/// <remarks>
		///   The Emit method is invoked to generate the code
		///   for the expression.  
		/// </remarks>
		public abstract void Emit (EmitContext ec);


		// Emit code to branch to @target if this expression is equivalent to @on_true.
		// The default implementation is to emit the value, and then emit a brtrue or brfalse.
		// Subclasses can provide more efficient implementations, but those MUST be equivalent,
		// including the use of conditional branches.  Note also that a branch MUST be emitted
		public virtual void EmitBranchable (EmitContext ec, Label target, bool on_true)
		{
			Emit (ec);
			ec.Emit (on_true ? OpCodes.Brtrue : OpCodes.Brfalse, target);
		}

		// Emit this expression for its side effects, not for its value.
		// The default implementation is to emit the value, and then throw it away.
		// Subclasses can provide more efficient implementations, but those MUST be equivalent
		public virtual void EmitSideEffect (EmitContext ec)
		{
			Emit (ec);
			ec.Emit (OpCodes.Pop);
		}

		//
		// Emits the expression into temporary field variable. The method
		// should be used for await expressions only
		//
		public virtual Expression EmitToField (EmitContext ec)
		{
			//
			// This is the await prepare Emit method. When emitting code like
			// a + b we emit code like
			//
			// a.Emit ()
			// b.Emit ()
			// Opcodes.Add
			//
			// For await a + await b we have to interfere the flow to keep the
			// stack clean because await yields from the expression. The emit
			// then changes to
			//
			// a = a.EmitToField ()	// a is changed to temporary field access
			// b = b.EmitToField ()
			// a.Emit ()
			// b.Emit ()
			// Opcodes.Add
			//
			//
			// The idea is to emit expression and leave the stack empty with
			// result value still available.
			//
			// Expressions should override this default implementation when
			// optimized version can be provided (e.g. FieldExpr)
			//
			//
			// We can optimize for side-effect free expressions, they can be
			// emitted out of order
			//
			if (IsSideEffectFree)
				return this;

			bool needs_temporary = ContainsEmitWithAwait ();
			if (!needs_temporary)
				ec.EmitThis ();

			// Emit original code
			var field = EmitToFieldSource (ec);
			if (field == null) {
				//
				// Store the result to temporary field when we
				// cannot load `this' directly
				//
				field = ec.GetTemporaryField (type);
				if (needs_temporary) {
					//
					// Create temporary local (we cannot load `this' before Emit)
					//
					var temp = ec.GetTemporaryLocal (type);
					ec.Emit (OpCodes.Stloc, temp);

					ec.EmitThis ();
					ec.Emit (OpCodes.Ldloc, temp);
					field.EmitAssignFromStack (ec);

					ec.FreeTemporaryLocal (temp, type);
				} else {
					field.EmitAssignFromStack (ec);
				}
			}

			return field;
		}

		protected virtual FieldExpr EmitToFieldSource (EmitContext ec)
		{
			//
			// Default implementation calls Emit method
			//
			Emit (ec);
			return null;
		}

		protected static void EmitExpressionsList (EmitContext ec, List<Expression> expressions)
		{
			if (ec.HasSet (BuilderContext.Options.AsyncBody)) {
				bool contains_await = false;

				for (int i = 1; i < expressions.Count; ++i) {
					if (expressions[i].ContainsEmitWithAwait ()) {
						contains_await = true;
						break;
					}
				}

				if (contains_await) {
					for (int i = 0; i < expressions.Count; ++i) {
						expressions[i] = expressions[i].EmitToField (ec);
					}
				}
			}

			for (int i = 0; i < expressions.Count; ++i) {
				expressions[i].Emit (ec);
			}
		}

		/// <summary>
		///   Protected constructor.  Only derivate types should
		///   be able to be created
		/// </summary>

		protected Expression ()
		{
		}

		/// <summary>
		///   Returns a fully formed expression after a MemberLookup
		/// </summary>
		/// 
		static Expression ExprClassFromMemberInfo (MemberSpec spec, Location loc)
		{
			if (spec is EventSpec)
				return new EventExpr ((EventSpec) spec, loc);
			if (spec is ConstSpec)
				return new ConstantExpr ((ConstSpec) spec, loc);
			if (spec is FieldSpec)
				return new FieldExpr ((FieldSpec) spec, loc);
			if (spec is PropertySpec)
				return new PropertyExpr ((PropertySpec) spec, loc);
			if (spec is TypeSpec)
				return new TypeExpression (((TypeSpec) spec), loc);

			return null;
		}

		public static MethodSpec ConstructorLookup (ResolveContext rc, TypeSpec type, ref Arguments args, Location loc)
		{
			var ctors = MemberCache.FindMembers (type, Constructor.ConstructorName, true);
			if (ctors == null) {
				switch (type.Kind) {
				case MemberKind.Struct:
					rc.Report.SymbolRelatedToPreviousError (type);
					// Report meaningful error for struct as they always have default ctor in C# context
					OverloadResolver.Error_ConstructorMismatch (rc, type, args == null ? 0 : args.Count, loc);
					break;
				case MemberKind.MissingType:
				case MemberKind.InternalCompilerType:
// LAMESPEC: dynamic is not really object
//					if (type.BuiltinType == BuiltinTypeSpec.Type.Object)
//						goto default;
					break;
				default:
					rc.Report.SymbolRelatedToPreviousError (type);
					rc.Report.Error (143, loc, "The class `{0}' has no constructors defined",
						type.GetSignatureForError ());
					break;
				}

				return null;
			}

			var r = new OverloadResolver (ctors, OverloadResolver.Restrictions.NoBaseMembers, loc);
			if (!rc.HasSet (ResolveContext.Options.BaseInitializer)) {
				r.InstanceQualifier = new ConstructorInstanceQualifier (type);
			}

			return r.ResolveMember<MethodSpec> (rc, ref args);
		}

		[Flags]
		public enum MemberLookupRestrictions
		{
			None = 0,
			InvocableOnly = 1,
			ExactArity = 1 << 2,
			ReadAccess = 1 << 3,
			EmptyArguments = 1 << 4,
			IgnoreArity = 1 << 5,
			IgnoreAmbiguity = 1 << 6
		}

		//
		// Lookup type `queried_type' for code in class `container_type' with a qualifier of
		// `qualifier_type' or null to lookup members in the current class.
		//
		public static Expression MemberLookup (IMemberContext rc, bool errorMode, TypeSpec queried_type, string name, int arity, MemberLookupRestrictions restrictions, Location loc)
		{
			var members = MemberCache.FindMembers (queried_type, name, false);
			if (members == null)
				return null;

			MemberSpec non_method = null;
			MemberSpec ambig_non_method = null;
			do {
				for (int i = 0; i < members.Count; ++i) {
					var member = members[i];

					// HACK: for events because +=/-= can appear at same class only, should use OverrideToBase there
					if ((member.Modifiers & Modifiers.OVERRIDE) != 0 && member.Kind != MemberKind.Event)
						continue;

					if ((member.Modifiers & Modifiers.BACKING_FIELD) != 0 || member.Kind == MemberKind.Operator)
						continue;

					if ((arity > 0 || (restrictions & MemberLookupRestrictions.ExactArity) != 0) && member.Arity != arity)
						continue;

					if (!errorMode) {
						if (!member.IsAccessible (rc))
							continue;

						//
						// With runtime binder we can have a situation where queried type is inaccessible
						// because it came via dynamic object, the check about inconsisted accessibility
						// had no effect as the type was unknown during compilation
						//
						// class A {
						//		private class N { }
						//
						//		public dynamic Foo ()
						//		{
						//			return new N ();
						//		}
						//	}
						//
						if (rc.Module.Compiler.IsRuntimeBinder && !member.DeclaringType.IsAccessible (rc))
							continue;
					}

					if ((restrictions & MemberLookupRestrictions.InvocableOnly) != 0) {
						if (member is MethodSpec) {
							//
							// Interface members that are hidden by class members are removed from the set. This
							// step only has an effect if T is a type parameter and T has both an effective base 
							// class other than object and a non-empty effective interface set
							//
							var tps = queried_type as TypeParameterSpec;
							if (tps != null && tps.HasTypeConstraint)
								members = RemoveHiddenTypeParameterMethods (members);

							return new MethodGroupExpr (members, queried_type, loc);
						}

						if (!Invocation.IsMemberInvocable (member))
							continue;
					}

					if (non_method == null || member is MethodSpec || non_method.IsNotCSharpCompatible) {
						non_method = member;
					} else if (!errorMode && !member.IsNotCSharpCompatible) {
						//
						// Interface members that are hidden by class members are removed from the set when T is a type parameter and
						// T has both an effective base class other than object and a non-empty effective interface set.
						//
						// The spec has more complex rules but we simply remove all members declared in an interface declaration.
						//
						var tps = queried_type as TypeParameterSpec;
						if (tps != null && tps.HasTypeConstraint) {
							if (non_method.DeclaringType.IsClass && member.DeclaringType.IsInterface)
								continue;

							if (non_method.DeclaringType.IsInterface && member.DeclaringType.IsInterface) {
								non_method = member;
								continue;
							}
						}

						ambig_non_method = member;
					}
				}

				if (non_method != null) {
					if (ambig_non_method != null && rc != null && (restrictions & MemberLookupRestrictions.IgnoreAmbiguity) == 0) {
						var report = rc.Module.Compiler.Report;
						report.SymbolRelatedToPreviousError (non_method);
						report.SymbolRelatedToPreviousError (ambig_non_method);
						report.Error (229, loc, "Ambiguity between `{0}' and `{1}'",
							non_method.GetSignatureForError (), ambig_non_method.GetSignatureForError ());
					}

					if (non_method is MethodSpec)
						return new MethodGroupExpr (members, queried_type, loc);

					return ExprClassFromMemberInfo (non_method, loc);
				}

				if (members[0].DeclaringType.BaseType == null)
					members = null;
				else
					members = MemberCache.FindMembers (members[0].DeclaringType.BaseType, name, false);

			} while (members != null);

			return null;
		}

		static IList<MemberSpec> RemoveHiddenTypeParameterMethods (IList<MemberSpec> members)
		{
			if (members.Count < 2)
				return members;

			//
			// If M is a method, then all non-method members declared in an interface declaration
			// are removed from the set, and all methods with the same signature as M declared in
			// an interface declaration are removed from the set
			//

			bool copied = false;
			for (int i = 0; i < members.Count; ++i) {
				var method = members[i] as MethodSpec;
				if (method == null) {
					if (!copied) {
						copied = true;
						members = new List<MemberSpec> (members);
					} 
					
					members.RemoveAt (i--);
					continue;
				}

				if (!method.DeclaringType.IsInterface)
					continue;

				for (int ii = 0; ii < members.Count; ++ii) {
					var candidate = members[ii] as MethodSpec;
					if (candidate == null || !candidate.DeclaringType.IsClass)
						continue;

					if (!TypeSpecComparer.Override.IsEqual (candidate.Parameters, method.Parameters))
						continue;

					if (!copied) {
						copied = true;
						members = new List<MemberSpec> (members);
					}

					members.RemoveAt (i--);
					break;
				}
			}

			return members;
		}

		protected virtual void Error_NegativeArrayIndex (ResolveContext ec, Location loc)
		{
			throw new NotImplementedException ();
		}

		public virtual void Error_OperatorCannotBeApplied (ResolveContext rc, Location loc, string oper, TypeSpec t)
		{
			if (t == InternalType.ErrorType)
				return;

			rc.Report.Error (23, loc, "The `{0}' operator cannot be applied to operand of type `{1}'",
				oper, t.GetSignatureForError ());
		}

		protected void Error_PointerInsideExpressionTree (ResolveContext ec)
		{
			ec.Report.Error (1944, loc, "An expression tree cannot contain an unsafe pointer operation");
		}

		protected void Error_NullShortCircuitInsideExpressionTree (ResolveContext rc)
		{
			rc.Report.Error (8072, loc, "An expression tree cannot contain a null propagating operator");
		}

		public virtual void FlowAnalysis (FlowAnalysisContext fc)
		{
		}

		//
		// Special version of flow analysis for expressions which can return different
		// on-true and on-false result. Used by &&, ||, ?: expressions
		//
		public virtual void FlowAnalysisConditional (FlowAnalysisContext fc)
		{
			FlowAnalysis (fc);
			fc.DefiniteAssignmentOnTrue = fc.DefiniteAssignmentOnFalse = fc.DefiniteAssignment;
		}

		/// <summary>
		///   Returns an expression that can be used to invoke operator true
		///   on the expression if it exists.
		/// </summary>
		protected static Expression GetOperatorTrue (ResolveContext ec, Expression e, Location loc)
		{
			return GetOperatorTrueOrFalse (ec, e, true, loc);
		}

		/// <summary>
		///   Returns an expression that can be used to invoke operator false
		///   on the expression if it exists.
		/// </summary>
		protected static Expression GetOperatorFalse (ResolveContext ec, Expression e, Location loc)
		{
			return GetOperatorTrueOrFalse (ec, e, false, loc);
		}

		static Expression GetOperatorTrueOrFalse (ResolveContext ec, Expression e, bool is_true, Location loc)
		{
			var op = is_true ? Operator.OpType.True : Operator.OpType.False;
			var methods = MemberCache.GetUserOperator (e.type, op, false);
			if (methods == null)
				return null;

			Arguments arguments = new Arguments (1);
			arguments.Add (new Argument (e));

			var res = new OverloadResolver (methods, OverloadResolver.Restrictions.BaseMembersIncluded | OverloadResolver.Restrictions.NoBaseMembers, loc);
			var oper = res.ResolveOperator (ec, ref arguments);

			if (oper == null)
				return null;

			return new UserOperatorCall (oper, arguments, null, loc);
		}
		
		public virtual string ExprClassName
		{
			get {
				switch (eclass){
				case ExprClass.Unresolved:
					return "Unresolved";
				case ExprClass.Value:
					return "value";
				case ExprClass.Variable:
					return "variable";
				case ExprClass.Namespace:
					return "namespace";
				case ExprClass.Type:
					return "type";
				case ExprClass.MethodGroup:
					return "method group";
				case ExprClass.PropertyAccess:
					return "property access";
				case ExprClass.EventAccess:
					return "event access";
				case ExprClass.IndexerAccess:
					return "indexer access";
				case ExprClass.Nothing:
					return "null";
				case ExprClass.TypeParameter:
					return "type parameter";
				}
				throw new Exception ("Should not happen");
			}
		}
		
		/// <summary>
		///   Reports that we were expecting `expr' to be of class `expected'
		/// </summary>
		public static void Error_UnexpectedKind (IMemberContext ctx, Expression memberExpr, string expected, string was, Location loc)
		{
			var name = memberExpr.GetSignatureForError ();

			ctx.Module.Compiler.Report.Error (118, loc, "`{0}' is a `{1}' but a `{2}' was expected", name, was, expected);
		}

		public virtual void Error_UnexpectedKind (ResolveContext ec, ResolveFlags flags, Location loc)
		{
			string [] valid = new string [4];
			int count = 0;

			if ((flags & ResolveFlags.VariableOrValue) != 0) {
				valid [count++] = "variable";
				valid [count++] = "value";
			}

			if ((flags & ResolveFlags.Type) != 0)
				valid [count++] = "type";

			if ((flags & ResolveFlags.MethodGroup) != 0)
				valid [count++] = "method group";

			if (count == 0)
				valid [count++] = "unknown";

			StringBuilder sb = new StringBuilder (valid [0]);
			for (int i = 1; i < count - 1; i++) {
				sb.Append ("', `");
				sb.Append (valid [i]);
			}
			if (count > 1) {
				sb.Append ("' or `");
				sb.Append (valid [count - 1]);
			}

			ec.Report.Error (119, loc, 
				"Expression denotes a `{0}', where a `{1}' was expected", ExprClassName, sb.ToString ());
		}
		
		public static void UnsafeError (ResolveContext ec, Location loc)
		{
			UnsafeError (ec.Report, loc);
		}

		public static void UnsafeError (Report Report, Location loc)
		{
			Report.Error (214, loc, "Pointers and fixed size buffers may only be used in an unsafe context");
		}

		//
		// Converts `source' to an int, uint, long or ulong.
		//
		protected Expression ConvertExpressionToArrayIndex (ResolveContext ec, Expression source, bool pointerArray = false)
		{
			var btypes = ec.BuiltinTypes;

			if (source.type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
				Arguments args = new Arguments (1);
				args.Add (new Argument (source));
				return new DynamicConversion (btypes.Int, CSharpBinderFlags.ConvertArrayIndex, args, loc).Resolve (ec);
			}

			Expression converted;
			
			using (ec.Set (ResolveContext.Options.CheckedScope)) {
				converted = Convert.ImplicitConversion (ec, source, btypes.Int, source.loc);
				if (converted == null)
					converted = Convert.ImplicitConversion (ec, source, btypes.UInt, source.loc);
				if (converted == null)
					converted = Convert.ImplicitConversion (ec, source, btypes.Long, source.loc);
				if (converted == null)
					converted = Convert.ImplicitConversion (ec, source, btypes.ULong, source.loc);

				if (converted == null) {
					source.Error_ValueCannotBeConverted (ec, btypes.Int, false);
					return null;
				}
			}

			if (pointerArray)
				return converted;

			//
			// Only positive constants are allowed at compile time
			//
			Constant c = converted as Constant;
			if (c != null && c.IsNegative)
				Error_NegativeArrayIndex (ec, source.loc);

			// No conversion needed to array index
			if (converted.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
				return converted;

			return new ArrayIndexCast (converted, btypes.Int).Resolve (ec);
		}

		//
		// Derived classes implement this method by cloning the fields that
		// could become altered during the Resolve stage
		//
		// Only expressions that are created for the parser need to implement
		// this.
		//
		protected virtual void CloneTo (CloneContext clonectx, Expression target)
		{
			throw new NotImplementedException (
				String.Format (
					"CloneTo not implemented for expression {0}", this.GetType ()));
		}

		//
		// Clones an expression created by the parser.
		//
		// We only support expressions created by the parser so far, not
		// expressions that have been resolved (many more classes would need
		// to implement CloneTo).
		//
		// This infrastructure is here merely for Lambda expressions which
		// compile the same code using different type values for the same
		// arguments to find the correct overload
		//
		public virtual Expression Clone (CloneContext clonectx)
		{
			Expression cloned = (Expression) MemberwiseClone ();
			CloneTo (clonectx, cloned);

			return cloned;
		}

		//
		// Implementation of expression to expression tree conversion
		//
		public abstract Expression CreateExpressionTree (ResolveContext ec);

		protected Expression CreateExpressionFactoryCall (ResolveContext ec, string name, Arguments args)
		{
			return CreateExpressionFactoryCall (ec, name, null, args, loc);
		}

		protected Expression CreateExpressionFactoryCall (ResolveContext ec, string name, TypeArguments typeArguments, Arguments args)
		{
			return CreateExpressionFactoryCall (ec, name, typeArguments, args, loc);
		}

		public static Expression CreateExpressionFactoryCall (ResolveContext ec, string name, TypeArguments typeArguments, Arguments args, Location loc)
		{
			return new Invocation (new MemberAccess (CreateExpressionTypeExpression (ec, loc), name, typeArguments, loc), args);
		}

		protected static TypeExpr CreateExpressionTypeExpression (ResolveContext ec, Location loc)
		{
			var t = ec.Module.PredefinedTypes.Expression.Resolve ();
			if (t == null)
				return null;

			return new TypeExpression (t, loc);
		}

		//
		// Implemented by all expressions which support conversion from
		// compiler expression to invokable runtime expression. Used by
		// dynamic C# binder.
		//
		public virtual SLE.Expression MakeExpression (BuilderContext ctx)
		{
			throw new NotImplementedException ("MakeExpression for " + GetType ());
		}
			
		public virtual object Accept (StructuralVisitor visitor)
		{
			return visitor.Visit (this);
		}
	}

	/// <summary>
	///   This is just a base class for expressions that can
	///   appear on statements (invocations, object creation,
	///   assignments, post/pre increment and decrement).  The idea
	///   being that they would support an extra Emition interface that
	///   does not leave a result on the stack.
	/// </summary>
	public abstract class ExpressionStatement : Expression
	{
		public virtual void MarkReachable (Reachability rc)
		{
		}

		public ExpressionStatement ResolveStatement (BlockContext ec)
		{
			Expression e = Resolve (ec);
			if (e == null)
				return null;

			ExpressionStatement es = e as ExpressionStatement;
			if (es == null || e is AnonymousMethodBody)
				Error_InvalidExpressionStatement (ec);

			//
			// This is quite expensive warning, try to limit the damage
			//
			if (MemberAccess.IsValidDotExpression (e.Type) && !(e is Assign || e is Await)) {
				WarningAsyncWithoutWait (ec, e);
			}

			return es;
		}

		static void WarningAsyncWithoutWait (BlockContext bc, Expression e)
		{
			if (bc.CurrentAnonymousMethod is AsyncInitializer) {
				var awaiter = new AwaitStatement.AwaitableMemberAccess (e) {
					ProbingMode = true
				};

				//
				// Need to do full resolve because GetAwaiter can be extension method
				// available only in this context
				//
				var mg = awaiter.Resolve (bc) as MethodGroupExpr;
				if (mg == null)
					return;

				var arguments = new Arguments (0);
				mg = mg.OverloadResolve (bc, ref arguments, null, OverloadResolver.Restrictions.ProbingOnly);
				if (mg == null)
					return;

				//
				// Use same check rules as for real await
				//
				var awaiter_definition = bc.Module.GetAwaiter (mg.BestCandidateReturnType);
				if (!awaiter_definition.IsValidPattern || !awaiter_definition.INotifyCompletion)
					return;

				bc.Report.Warning (4014, 1, e.Location,
					"The statement is not awaited and execution of current method continues before the call is completed. Consider using `await' operator");
				return;
			}

			var inv = e as Invocation;
			if (inv != null && inv.MethodGroup != null && inv.MethodGroup.BestCandidate.IsAsync) {
				// The warning won't be reported for imported methods to maintain warning compatiblity with csc 
				bc.Report.Warning (4014, 1, e.Location,
					"The statement is not awaited and execution of current method continues before the call is completed. Consider using `await' operator or calling `Wait' method");
				return;
			}
		}

		/// <summary>
		///   Requests the expression to be emitted in a `statement'
		///   context.  This means that no new value is left on the
		///   stack after invoking this method (constrasted with
		///   Emit that will always leave a value on the stack).
		/// </summary>
		public abstract void EmitStatement (EmitContext ec);

		public override void EmitSideEffect (EmitContext ec)
		{
			EmitStatement (ec);
		}
	}

	/// <summary>
	///   This kind of cast is used to encapsulate the child
	///   whose type is child.Type into an expression that is
	///   reported to return "return_type".  This is used to encapsulate
	///   expressions which have compatible types, but need to be dealt
	///   at higher levels with.
	///
	///   For example, a "byte" expression could be encapsulated in one
	///   of these as an "unsigned int".  The type for the expression
	///   would be "unsigned int".
	///
	/// </summary>
	public abstract class TypeCast : Expression
	{
		protected readonly Expression child;

		protected TypeCast (Expression child, TypeSpec return_type)
		{
			eclass = child.eclass;
			loc = child.Location;
			type = return_type;
			this.child = child;
		}

		public Expression Child {
			get {
				return child;
			}
		}

		public override bool ContainsEmitWithAwait ()
		{
			return child.ContainsEmitWithAwait ();
		}

		public override Expression CreateExpressionTree (ResolveContext ec)
		{
			Arguments args = new Arguments (2);
			args.Add (new Argument (child.CreateExpressionTree (ec)));
			args.Add (new Argument (new TypeOf (type, loc)));

			if (type.IsPointer || child.Type.IsPointer)
				Error_PointerInsideExpressionTree (ec);

			return CreateExpressionFactoryCall (ec, ec.HasSet (ResolveContext.Options.CheckedScope) ? "ConvertChecked" : "Convert", args);
		}

		protected override Expression DoResolve (ResolveContext ec)
		{
			// This should never be invoked, we are born in fully
			// initialized state.

			return this;
		}

		public override void Emit (EmitContext ec)
		{
			child.Emit (ec);
		}

		public override void FlowAnalysis (FlowAnalysisContext fc)
		{
			child.FlowAnalysis (fc);
		}

		public override SLE.Expression MakeExpression (BuilderContext ctx)
		{
#if STATIC
			return base.MakeExpression (ctx);
#else
			return ctx.HasSet (BuilderContext.Options.CheckedScope) ?
				SLE.Expression.ConvertChecked (child.MakeExpression (ctx), type.GetMetaInfo ()) :
				SLE.Expression.Convert (child.MakeExpression (ctx), type.GetMetaInfo ());
#endif
		}

		protected override void CloneTo (CloneContext clonectx, Expression t)
		{
			// Nothing to clone
		}

		public override bool IsNull {
			get { return child.IsNull; }
		}
	}

	public class EmptyCast : TypeCast {
		EmptyCast (Expression child, TypeSpec target_type)
			: base (child, target_type)
		{
		}

		public static Expression Create (Expression child, TypeSpec type)
		{
			Constant c = child as Constant;
			if (c != null) {
				var enum_constant = c as EnumConstant;
				if (enum_constant != null)
					c = enum_constant.Child;

				if (!(c is ReducedExpression.ReducedConstantExpression)) {
					if (c.Type == type)
						return c;

					var res = c.ConvertImplicitly (type);
					if (res != null)
						return res;
				}
			}

			EmptyCast e = child as EmptyCast;
			if (e != null)
				return new EmptyCast (e.child, type);

			return new EmptyCast (child, type);
		}

		public override void EmitBranchable (EmitContext ec, Label label, bool on_true)
		{
			child.EmitBranchable (ec, label, on_true);
		}

		public override void EmitSideEffect (EmitContext ec)
		{
			child.EmitSideEffect (ec);
		}
	}

	//
	// Used for predefined type user operator (no obsolete check, etc.)
	//
	public class OperatorCast : TypeCast
	{
		readonly MethodSpec conversion_operator;

		public OperatorCast (Expression expr, TypeSpec target_type)
			: this (expr, target_type, target_type, false)
		{
		}
		
		public OperatorCast (Expression expr, TypeSpec target_type, bool find_explicit)
			: this (expr, target_type, target_type, find_explicit)
		{
		}
		
		public OperatorCast (Expression expr, TypeSpec declaringType, TypeSpec returnType, bool isExplicit)
			: base (expr, returnType)
		{
			var op = isExplicit ? Operator.OpType.Explicit : Operator.OpType.Implicit;
			var mi = MemberCache.GetUserOperator (declaringType, op, true);

			if (mi != null) {
				foreach (MethodSpec oper in mi) {
					if (oper.ReturnType != returnType)
						continue;

					if (oper.Parameters.Types[0] == expr.Type) {
						conversion_operator = oper;
						return;
					}
				}
			}

			throw new InternalErrorException ("Missing predefined user operator between `{0}' and `{1}'",
				returnType.GetSignatureForError (), expr.Type.GetSignatureForError ());
		}

		public override void Emit (EmitContext ec)
		{
			child.Emit (ec);
			ec.Emit (OpCodes.Call, conversion_operator);
		}
	}
	
	//
	// Constant specialization of EmptyCast.
	// We need to special case this since an empty cast of
	// a constant is still a constant. 
	//
	public class EmptyConstantCast : Constant
	{
		public readonly Constant child;

		public EmptyConstantCast (Constant child, TypeSpec type)
			: base (child.Location)
		{
			if (child == null)
				throw new ArgumentNullException ("child");

			this.child = child;
			this.eclass = child.eclass;
			this.type = type;
		}

		public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
		{
			if (child.Type == target_type)
				return child;

			// FIXME: check that 'type' can be converted to 'target_type' first
			return child.ConvertExplicitly (in_checked_context, target_type);
		}

		public override Expression CreateExpressionTree (ResolveContext ec)
		{
			Arguments args = Arguments.CreateForExpressionTree (ec, null,
				child.CreateExpressionTree (ec),
				new TypeOf (type, loc));

			if (type.IsPointer)
				Error_PointerInsideExpressionTree (ec);

			return CreateExpressionFactoryCall (ec, "Convert", args);
		}

		public override bool IsDefaultValue {
			get { return child.IsDefaultValue; }
		}

		public override bool IsNegative {
			get { return child.IsNegative; }
		}

		public override bool IsNull {
			get { return child.IsNull; }
		}
		
		public override bool IsOneInteger {
			get { return child.IsOneInteger; }
		}

		public override bool IsSideEffectFree {
			get {
				return child.IsSideEffectFree;
			}
		}

		public override bool IsZeroInteger {
			get { return child.IsZeroInteger; }
		}

		public override void Emit (EmitContext ec)
		{
			child.Emit (ec);			
		}

		public override void EmitBranchable (EmitContext ec, Label label, bool on_true)
		{
			child.EmitBranchable (ec, label, on_true);

			// Only to make verifier happy
			if (TypeManager.IsGenericParameter (type) && child.IsNull)
				ec.Emit (OpCodes.Unbox_Any, type);
		}

		public override void EmitSideEffect (EmitContext ec)
		{
			child.EmitSideEffect (ec);
		}

		public override object GetValue ()
		{
			return child.GetValue ();
		}

		public override string GetValueAsLiteral ()
		{
			return child.GetValueAsLiteral ();
		}

		public override long GetValueAsLong ()
		{
			return child.GetValueAsLong ();
		}

		public override Constant ConvertImplicitly (TypeSpec target_type)
		{
			if (type == target_type)
				return this;

			// FIXME: Do we need to check user conversions?
			if (!Convert.ImplicitStandardConversionExists (this, target_type))
				return null;

			return child.ConvertImplicitly (target_type);
		}
	}

	/// <summary>
	///  This class is used to wrap literals which belong inside Enums
	/// </summary>
	public class EnumConstant : Constant
	{
		public Constant Child;

		public EnumConstant (Constant child, TypeSpec enum_type)
			: base (child.Location)
		{
			this.Child = child;

			this.eclass = ExprClass.Value;
			this.type = enum_type;
		}

		protected EnumConstant (Location loc)
			: base (loc)
		{
		}

		public override void Emit (EmitContext ec)
		{
			Child.Emit (ec);
		}

		public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
		{
			Child.EncodeAttributeValue (rc, enc, Child.Type, parameterType);
		}

		public override void EmitBranchable (EmitContext ec, Label label, bool on_true)
		{
			Child.EmitBranchable (ec, label, on_true);
		}

		public override void EmitSideEffect (EmitContext ec)
		{
			Child.EmitSideEffect (ec);
		}

		public override string GetSignatureForError()
		{
			return Type.GetSignatureForError ();
		}

		public override object GetValue ()
		{
			return Child.GetValue ();
		}

#if !STATIC
		public override object GetTypedValue ()
		{
			//
			// The method can be used in dynamic context only (on closed types)
			//
			// System.Enum.ToObject cannot be called on dynamic types
			// EnumBuilder has to be used, but we cannot use EnumBuilder
			// because it does not properly support generics
			//
			return System.Enum.ToObject (type.GetMetaInfo (), Child.GetValue ());
		}
#endif

		public override string GetValueAsLiteral ()
		{
			return Child.GetValueAsLiteral ();
		}

		public override long GetValueAsLong ()
		{
			return Child.GetValueAsLong ();
		}

		public EnumConstant Increment()
		{
			return new EnumConstant (((IntegralConstant) Child).Increment (), type);
		}

		public override bool IsDefaultValue {
			get {
				return Child.IsDefaultValue;
			}
		}

		public override bool IsSideEffectFree {
			get {
				return Child.IsSideEffectFree;
			}
		}

		public override bool IsZeroInteger {
			get { return Child.IsZeroInteger; }
		}

		public override bool IsNegative {
			get {
				return Child.IsNegative;
			}
		}

		public override Constant ConvertExplicitly (bool in_checked_context, TypeSpec target_type)
		{
			if (Child.Type == target_type)
				return Child;

			return Child.ConvertExplicitly (in_checked_context, target_type);
		}

		public override Constant ConvertImplicitly (TypeSpec type)
		{
			if (this.type == type) {
				return this;
			}

			if (!Convert.ImplicitStandardConve…