X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fanonymous.cs;h=75b4b29457b45cfd23dd342ab4ff51111ffcb31a;hb=cd5d5a8abe403c911b2a348122d9bc2f75b350c4;hp=e8c2b63417a2558a205b339bfc87d787905723d7;hpb=1ae1097379d74871c14e059b6ba1101e7c7a4ef0;p=mono.git diff --git a/mcs/mcs/anonymous.cs b/mcs/mcs/anonymous.cs index e8c2b63417a..75b4b29457b 100644 --- a/mcs/mcs/anonymous.cs +++ b/mcs/mcs/anonymous.cs @@ -58,12 +58,13 @@ namespace Mono.CSharp { public class AnonymousMethodStorey : CompilerGeneratedClass { class StoreyFieldPair { - public AnonymousMethodStorey Storey; - public Field Field; + public readonly AnonymousMethodStorey Storey; + public readonly Field Field; - public StoreyFieldPair (AnonymousMethodStorey storey) + public StoreyFieldPair (AnonymousMethodStorey storey, Field field) { this.Storey = storey; + this.Field = field; } public override int GetHashCode () @@ -77,21 +78,55 @@ namespace Mono.CSharp { } } - class HoistedGenericField : Field + sealed class HoistedGenericField : Field { public HoistedGenericField (DeclSpace parent, FullNamedExpression type, int mod, string name, Attributes attrs, Location loc) - : base (parent, type, mod, name, attrs, loc) + : base (parent, type, mod, new MemberName (name, loc), attrs) { } - public override bool Define () + protected override bool ResolveMemberType () { + if (!base.ResolveMemberType ()) + return false; + AnonymousMethodStorey parent = ((AnonymousMethodStorey) Parent).GetGenericStorey (); if (parent != null) - type_name.Type = parent.MutateType (type_name.Type); + member_type = parent.MutateType (member_type); - return base.Define (); + return true; + } + } + + // + // Needed to delay hoisted _this_ initialization. When an anonymous + // method is used inside ctor and _this_ is hoisted, base ctor has to + // be called first, otherwise _this_ will be initialized with + // uninitialized value. + // + sealed class ThisInitializer : Statement + { + readonly HoistedThis hoisted_this; + + public ThisInitializer (HoistedThis hoisted_this) + { + this.hoisted_this = hoisted_this; + } + + protected override void DoEmit (EmitContext ec) + { + hoisted_this.EmitHoistingAssignment (ec); + } + + protected override void CloneTo (CloneContext clonectx, Statement target) + { + // Nothing to clone + } + + public override void MutateHoistedGenericType (AnonymousMethodStorey storey) + { + // Nothing to mutate } } @@ -103,23 +138,18 @@ namespace Mono.CSharp { // A list of StoreyFieldPair with local field keeping parent storey instance ArrayList used_parent_storeys; + ArrayList children_references; // A list of hoisted parameters protected ArrayList hoisted_params; + protected ArrayList hoisted_locals; // Hoisted this - HoistedThis hoisted_this; + protected HoistedThis hoisted_this; // Local variable which holds this storey instance public LocalTemporary Instance; - bool references_defined; - bool has_hoisted_variable; - - // When propagating storey reference we may capture - // parent storey reference which is not used later - public bool IsParentStoreyUsed; - public AnonymousMethodStorey (Block block, DeclSpace parent, MemberBase host, GenericMethod generic, string name) : base (parent, generic, MakeMemberName (host, name, generic, block.StartLocation), Modifiers.PRIVATE) { @@ -134,14 +164,22 @@ namespace Mono.CSharp { string tname = MakeName (host_name, "c", name, unique_id); TypeArguments args = null; if (generic != null) { - args = new TypeArguments (loc); + args = new TypeArguments (); foreach (TypeParameter tparam in generic.CurrentTypeParameters) - args.Add (new SimpleName (tparam.Name, loc)); + args.Add (new TypeParameterName (tparam.Name, null, loc)); } return new MemberName (tname, args, loc); } + public void AddCapturedThisField (EmitContext ec) + { + TypeExpr type_expr = new TypeExpression (ec.ContainerType, Location); + Field f = AddCompilerGeneratedField ("<>f__this", type_expr); + f.Define (); + hoisted_this = new HoistedThis (this, f); + } + public Field AddCapturedVariable (string name, Type type) { CheckMembersDefined (); @@ -159,37 +197,65 @@ namespace Mono.CSharp { protected Field AddCompilerGeneratedField (string name, FullNamedExpression type) { const int mod = Modifiers.INTERNAL | Modifiers.COMPILER_GENERATED; - Field f = new Field (this, type, mod, name, null, Location); + Field f = new Field (this, type, mod, new MemberName (name, Location), null); AddField (f); return f; } - public void AddParentStoreyReference (AnonymousMethodStorey s) + // + // Creates a link between block and the anonymous method storey + // + // An anonymous method can reference variables from any outer block, but they are + // hoisted in their own ExplicitBlock. When more than one block is referenced we + // need to create another link between those variable storeys + // + public void AddReferenceFromChildrenBlock (ExplicitBlock block) + { + if (children_references == null) + children_references = new ArrayList (); + + if (!children_references.Contains (block)) + children_references.Add (block); + } + + public void AddParentStoreyReference (AnonymousMethodStorey storey) { CheckMembersDefined (); if (used_parent_storeys == null) used_parent_storeys = new ArrayList (); - else if (used_parent_storeys.IndexOf (s) != -1) + else if (used_parent_storeys.IndexOf (storey) != -1) return; - has_hoisted_variable = true; - used_parent_storeys.Add (new StoreyFieldPair (s)); + TypeExpr type_expr = new TypeExpression (storey.TypeBuilder, Location); + Field f = AddCompilerGeneratedField ("<>f__ref$" + storey.ID, type_expr); + used_parent_storeys.Add (new StoreyFieldPair (storey, f)); } public void CaptureLocalVariable (EmitContext ec, LocalInfo local_info) { + ec.CurrentBlock.Explicit.HasCapturedVariable = true; + if (ec.CurrentBlock.Explicit != local_info.Block.Explicit) + AddReferenceFromChildrenBlock (ec.CurrentBlock.Explicit); + if (local_info.HoistedVariableReference != null) return; HoistedVariable var = new HoistedLocalVariable (this, local_info, GetVariableMangledName (local_info)); local_info.HoistedVariableReference = var; - has_hoisted_variable = true; + + if (hoisted_locals == null) + hoisted_locals = new ArrayList (); + + hoisted_locals.Add (var); } public void CaptureParameter (EmitContext ec, ParameterReference param_ref) { - if (param_ref.HoistedVariable != null) + ec.CurrentBlock.Explicit.HasCapturedVariable = true; + AddReferenceFromChildrenBlock (ec.CurrentBlock.Explicit); + + if (param_ref.GetHoistedVariable (ec) != null) return; if (hoisted_params == null) @@ -200,63 +266,23 @@ namespace Mono.CSharp { hoisted_params.Add (expr); } - public HoistedThis CaptureThis (EmitContext ec, This t) - { - hoisted_this = new HoistedThis (this, t); - return hoisted_this; - } - public void ChangeParentStorey (AnonymousMethodStorey parentStorey) { Parent = parentStorey; type_params = null; } - void DefineStoreyReferences () - { - if (used_parent_storeys == null || references_defined) - return; - - references_defined = true; - if (!IsParentStoreyUsed) { - used_parent_storeys = null; - return; - } - - // - // For each used variable from parent scope we allocate its local reference point - // - for (int i = 0; i < used_parent_storeys.Count; ++i) { - StoreyFieldPair sf = (StoreyFieldPair) used_parent_storeys [i]; - AnonymousMethodStorey p_storey = sf.Storey; - TypeExpr type_expr = new TypeExpression (p_storey.TypeBuilder, Location); - - sf.Field = AddCompilerGeneratedField ("<>f__ref$" + p_storey.ID, type_expr); - sf.Field.Define (); - } - } - // // Initializes all hoisted variables // - public void EmitHoistedVariables (EmitContext ec) + public void EmitStoreyInstantiation (EmitContext ec) { // There can be only one instance variable for each storey type if (Instance != null) throw new InternalErrorException (); - // - // A storey with hoisted `this' is an instance method - // - if (!HasHoistedVariables) { - hoisted_this.RemoveHoisting (); - return; - } - SymbolWriter.OpenCompilerGeneratedBlock (ec.ig); - DefineStoreyReferences (); - // // Create an instance of storey type // @@ -266,19 +292,22 @@ namespace Mono.CSharp { // Use current method type parameter (MVAR) for top level storey only. All // nested storeys use class type parameter (VAR) // - TypeParameter[] tparams = ec.CurrentAnonymousMethod != null ? - ec.CurrentAnonymousMethod.Storey.CurrentTypeParameters : - ec.GenericDeclContainer.CurrentTypeParameters; - - if (tparams.Length != CountTypeParameters) { - TypeParameter [] full = new TypeParameter [CountTypeParameters]; - DeclSpace parent = ec.DeclContainer.Parent; - parent.CurrentTypeParameters.CopyTo (full, 0); - tparams.CopyTo (full, parent.CountTypeParameters); - tparams = full; + TypeParameter[] tparams = ec.CurrentAnonymousMethod != null && ec.CurrentAnonymousMethod.Storey != null ? + ec.CurrentAnonymousMethod.Storey.TypeParameters : + ec.GenericDeclContainer.TypeParameters; + + TypeArguments targs = new TypeArguments (); + + if (tparams.Length < CountTypeParameters) { + TypeParameter[] parent_tparams = ec.DeclContainer.Parent.PartialContainer.TypeParameters; + for (int i = 0; i < parent_tparams.Length; ++i) + targs.Add (new TypeParameterExpr (parent_tparams[i], Location)); } + + for (int i = 0; i < tparams.Length; ++i) + targs.Add (new TypeParameterExpr (tparams[i], Location)); - storey_type_expr = new ConstructedType (TypeBuilder, tparams, Location); + storey_type_expr = new GenericTypeExpr (TypeBuilder, targs, Location); } else { storey_type_expr = new TypeExpression (TypeBuilder, Location); } @@ -289,10 +318,9 @@ namespace Mono.CSharp { Instance = new LocalTemporary (storey_type_expr.Type); Instance.Store (ec); - SymbolWriter.DefineScopeVariable (ID, Instance.Builder); - EmitHoistedFieldsInitialization (ec); + SymbolWriter.DefineScopeVariable (ID, Instance.Builder); SymbolWriter.CloseCompilerGeneratedBlock (ec.ig); } @@ -318,6 +346,14 @@ namespace Mono.CSharp { } } + // + // Define hoisted `this' in top-level storey only + // + if (OriginalSourceBlock.Explicit.HasCapturedThis && !(Parent is AnonymousMethodStorey)) { + AddCapturedThisField (ec); + OriginalSourceBlock.AddScopeStatement (new ThisInitializer (hoisted_this)); + } + // // Setting currect anonymous method to null blocks any further variable hoisting // @@ -325,18 +361,19 @@ namespace Mono.CSharp { ec.CurrentAnonymousMethod = null; if (hoisted_params != null) { - foreach (HoistedParameter hp in hoisted_params) { - hp.EmitHoistingAssignment (ec); - } - } - - if (hoisted_this != null) { - hoisted_this.EmitHoistingAssignment (ec); + EmitHoistedParameters (ec, hoisted_params); } ec.CurrentAnonymousMethod = ae; } + protected virtual void EmitHoistedParameters (EmitContext ec, ArrayList hoisted) + { + foreach (HoistedParameter hp in hoisted) { + hp.EmitHoistingAssignment (ec); + } + } + public override void EmitType () { SymbolWriter.DefineAnonymousScope (ID); @@ -344,10 +381,9 @@ namespace Mono.CSharp { if (hoisted_this != null) hoisted_this.EmitSymbolInfo (); - foreach (LocalInfo li in OriginalSourceBlock.Variables.Values) { - HoistedVariable hv = li.HoistedVariableReference; - if (hv != null) - hv.EmitSymbolInfo (); + if (hoisted_locals != null) { + foreach (HoistedVariable local in hoisted_locals) + local.EmitSymbolInfo (); } if (hoisted_params != null) { @@ -355,8 +391,6 @@ namespace Mono.CSharp { param.EmitSymbolInfo (); } - DefineStoreyReferences (); - if (used_parent_storeys != null) { foreach (StoreyFieldPair sf in used_parent_storeys) { SymbolWriter.DefineCapturedScope (ID, sf.Storey.ID, sf.Field.Name); @@ -441,17 +475,8 @@ namespace Mono.CSharp { return local_info.Name; } - // - // Returns true when at least one local variable or parameter is - // hoisted, or story is transitioned - // - public bool HasHoistedVariables { - get { - return has_hoisted_variable || hoisted_params != null; - } - set { - has_hoisted_variable = value; - } + public HoistedThis HoistedThis { + get { return hoisted_this; } } // @@ -483,7 +508,7 @@ namespace Mono.CSharp { Type t = MutateGenericType (method.DeclaringType); if (t != method.DeclaringType) { method = (MethodInfo) TypeManager.DropGenericMethodArguments (method); - if (method.Module == CodeGen.Module.Builder) + if (method.Module == Module.Builder) method = TypeBuilder.GetMethod (t, method); else method = (MethodInfo) MethodInfo.GetMethodFromHandle (method.MethodHandle, t.TypeHandle); @@ -508,8 +533,11 @@ namespace Mono.CSharp { if (TypeManager.IsGenericType (ctor.DeclaringType)) { Type t = MutateGenericType (ctor.DeclaringType); if (t != ctor.DeclaringType) { - // TODO: It should throw on imported types - return TypeBuilder.GetConstructor (t, ctor); + ctor = (ConstructorInfo) TypeManager.DropGenericMethodArguments (ctor); + if (ctor.Module == Module.Builder) + return TypeBuilder.GetConstructor (t, ctor); + + return (ConstructorInfo) ConstructorInfo.GetMethodFromHandle (ctor.MethodHandle, t.TypeHandle); } } #endif @@ -535,10 +563,9 @@ namespace Mono.CSharp { { int rank = array.GetArrayRank (); Type element = TypeManager.GetElementType (array); - if (element.IsArray) - throw new NotImplementedException (); - - if (TypeManager.IsGenericParameter (element)) { + if (element.IsArray) { + element = MutateArrayType (element); + } else if (TypeManager.IsGenericParameter (element)) { element = MutateGenericArgument (element); } else if (TypeManager.IsGenericType (element)) { element = MutateGenericType (element); @@ -558,7 +585,7 @@ namespace Mono.CSharp { for (int i = 0; i < t_args.Length; ++i) t_args [i] = MutateType (t_args [i]); - return type.GetGenericTypeDefinition ().MakeGenericType (t_args); + return TypeManager.DropGenericTypeArguments (type).MakeGenericType (t_args); } #endif @@ -576,16 +603,14 @@ namespace Mono.CSharp { return type; } + public ArrayList ReferencesFromChildrenBlock { + get { return children_references; } + } + public static void Reset () { unique_id = 0; - } - - public void Undo () - { - if (hoisted_this != null) - hoisted_this.RemoveHoisting (); - } + } } public abstract class HoistedVariable @@ -624,12 +649,17 @@ namespace Mono.CSharp { protected readonly AnonymousMethodStorey storey; protected Field field; Hashtable cached_inner_access; // TODO: Hashtable is too heavyweight + FieldExpr cached_outer_access; protected HoistedVariable (AnonymousMethodStorey storey, string name, Type type) + : this (storey, storey.AddCapturedVariable (name, type)) { - this.storey = storey; + } - this.field = storey.AddCapturedVariable (name, type); + protected HoistedVariable (AnonymousMethodStorey storey, Field field) + { + this.storey = storey; + this.field = field; } public void AddressOf (EmitContext ec, AddressOp mode) @@ -652,18 +682,21 @@ namespace Mono.CSharp { // protected FieldExpr GetFieldExpression (EmitContext ec) { - if (ec.CurrentAnonymousMethod == null) { + if (ec.CurrentAnonymousMethod == null || ec.CurrentAnonymousMethod.Storey == null) { + if (cached_outer_access != null) + return cached_outer_access; + // // When setting top-level hoisted variable in generic storey // change storey generic types to method generic types (VAR -> MVAR) // - FieldExpr outer_access = storey.MemberName.IsGeneric ? + cached_outer_access = storey.MemberName.IsGeneric ? new FieldExpr (field.FieldBuilder, storey.Instance.Type, field.Location) : new FieldExpr (field.FieldBuilder, field.Location); - outer_access.InstanceExpression = storey.GetStoreyInstanceExpression (ec); - outer_access.Resolve (ec); - return outer_access; + cached_outer_access.InstanceExpression = storey.GetStoreyInstanceExpression (ec); + cached_outer_access.Resolve (ec); + return cached_outer_access; } FieldExpr inner_access; @@ -699,7 +732,7 @@ namespace Mono.CSharp { class HoistedParameter : HoistedVariable { - class HoistedFieldAssign : Assign + sealed class HoistedFieldAssign : Assign { public HoistedFieldAssign (Expression target, Expression source) : base (target, source, source.Location) @@ -724,6 +757,12 @@ namespace Mono.CSharp { this.parameter = par; } + public HoistedParameter (HoistedParameter hp, string name) + : base (hp.storey, name, hp.parameter.Type) + { + this.parameter = hp.parameter; + } + public void EmitHoistingAssignment (EmitContext ec) { // @@ -767,17 +806,14 @@ namespace Mono.CSharp { public class HoistedThis : HoistedVariable { - readonly This this_reference; - - public HoistedThis (AnonymousMethodStorey storey, This this_reference) - : base (storey, "<>f__this", this_reference.Type) + public HoistedThis (AnonymousMethodStorey storey, Field field) + : base (storey, field) { - this.this_reference = this_reference; } public void EmitHoistingAssignment (EmitContext ec) { - SimpleAssign a = new SimpleAssign (GetFieldExpression (ec), this_reference); + SimpleAssign a = new SimpleAssign (GetFieldExpression (ec), ec.GetThis (field.Location)); if (a.Resolve (ec) != null) a.EmitStatement (ec); } @@ -787,9 +823,8 @@ namespace Mono.CSharp { SymbolWriter.DefineCapturedThis (storey.ID, field.Name); } - public void RemoveHoisting () - { - this_reference.RemoveHoisting (); + public Field Field { + get { return field; } } } @@ -798,13 +833,11 @@ namespace Mono.CSharp { // public class AnonymousMethodExpression : Expression { - public readonly Parameters Parameters; ListDictionary compatibles; public ToplevelBlock Block; - public AnonymousMethodExpression (Parameters parameters, Location loc) + public AnonymousMethodExpression (Location loc) { - this.Parameters = parameters; this.loc = loc; this.compatibles = new ListDictionary (); } @@ -817,9 +850,13 @@ namespace Mono.CSharp { public virtual bool HasExplicitParameters { get { - return Parameters != null; + return Parameters != ParametersCompiled.Undefined; } } + + public ParametersCompiled Parameters { + get { return Block.Parameters; } + } // // Returns true if the body of lambda expression can be implicitly @@ -827,8 +864,10 @@ namespace Mono.CSharp { // public bool ImplicitStandardConversionExists (EmitContext ec, Type delegate_type) { - using (ec.Set (EmitContext.Flags.ProbingMode)) { - return Compatible (ec, delegate_type) != null; + using (ec.With (EmitContext.Flags.InferReturnType, false)) { + using (ec.Set (EmitContext.Flags.ProbingMode)) { + return Compatible (ec, delegate_type) != null; + } } } @@ -837,7 +876,6 @@ namespace Mono.CSharp { if (TypeManager.IsDelegateType (delegate_type)) return delegate_type; -#if GMCS_SOURCE if (TypeManager.DropGenericTypeArguments (delegate_type) == TypeManager.expression_type) { delegate_type = TypeManager.GetTypeArguments (delegate_type) [0]; if (TypeManager.IsDelegateType (delegate_type)) @@ -847,14 +885,13 @@ namespace Mono.CSharp { GetSignatureForError (), TypeManager.CSharpName (delegate_type)); return null; } -#endif Report.Error (1660, loc, "Cannot convert `{0}' to non-delegate type `{1}'", GetSignatureForError (), TypeManager.CSharpName (delegate_type)); return null; } - protected bool VerifyExplicitParameters (Type delegate_type, ParameterData parameters, bool ignore_error) + protected bool VerifyExplicitParameters (Type delegate_type, AParametersCollection parameters, bool ignore_error) { if (VerifyParameterCompatibility (delegate_type, parameters, ignore_error)) return true; @@ -867,7 +904,7 @@ namespace Mono.CSharp { return false; } - protected bool VerifyParameterCompatibility (Type delegate_type, ParameterData invoke_pd, bool ignore_errors) + protected bool VerifyParameterCompatibility (Type delegate_type, AParametersCollection invoke_pd, bool ignore_errors) { if (Parameters.Count != invoke_pd.Count) { if (ignore_errors) @@ -877,27 +914,28 @@ namespace Mono.CSharp { TypeManager.CSharpName (delegate_type), Parameters.Count.ToString ()); return false; } - - if (!HasExplicitParameters) - return true; + bool has_implicit_parameters = !HasExplicitParameters; bool error = false; + for (int i = 0; i < Parameters.Count; ++i) { - Parameter.Modifier p_mod = invoke_pd.ParameterModifier (i); - if (Parameters.ParameterModifier (i) != p_mod && p_mod != Parameter.Modifier.PARAMS) { + Parameter.Modifier p_mod = invoke_pd.FixedParameters [i].ModFlags; + if (Parameters.FixedParameters [i].ModFlags != p_mod && p_mod != Parameter.Modifier.PARAMS) { if (ignore_errors) return false; if (p_mod == Parameter.Modifier.NONE) Report.Error (1677, loc, "Parameter `{0}' should not be declared with the `{1}' keyword", - (i + 1).ToString (), Parameter.GetModifierSignature (Parameters.ParameterModifier (i))); + (i + 1).ToString (), Parameter.GetModifierSignature (Parameters.FixedParameters [i].ModFlags)); else Report.Error (1676, loc, "Parameter `{0}' must be declared with the `{1}' keyword", (i+1).ToString (), Parameter.GetModifierSignature (p_mod)); error = true; - continue; } + if (has_implicit_parameters) + continue; + Type type = invoke_pd.Types [i]; // We assume that generic parameters are always inflated @@ -907,14 +945,14 @@ namespace Mono.CSharp { if (TypeManager.HasElementType (type) && TypeManager.IsGenericParameter (TypeManager.GetElementType (type))) continue; - if (invoke_pd.ParameterType (i) != Parameters.ParameterType (i)) { + if (invoke_pd.Types [i] != Parameters.Types [i]) { if (ignore_errors) return false; Report.Error (1678, loc, "Parameter `{0}' is declared as type `{1}' but should be `{2}'", (i+1).ToString (), - TypeManager.CSharpName (Parameters.ParameterType (i)), - TypeManager.CSharpName (invoke_pd.ParameterType (i))); + TypeManager.CSharpName (Parameters.Types [i]), + TypeManager.CSharpName (invoke_pd.Types [i])); error = true; } } @@ -931,19 +969,15 @@ namespace Mono.CSharp { return false; if (!TypeManager.IsDelegateType (delegate_type)) { -#if GMCS_SOURCE if (TypeManager.DropGenericTypeArguments (delegate_type) != TypeManager.expression_type) return false; - delegate_type = delegate_type.GetGenericArguments () [0]; + delegate_type = TypeManager.GetTypeArguments (delegate_type) [0]; if (!TypeManager.IsDelegateType (delegate_type)) return false; -#else - return false; -#endif } - ParameterData d_params = TypeManager.GetDelegateParameters (delegate_type); + AParametersCollection d_params = TypeManager.GetDelegateParameters (delegate_type); if (d_params.Count != Parameters.Count) return false; @@ -953,10 +987,10 @@ namespace Mono.CSharp { if (!TypeManager.HasElementType (itype)) continue; - if (!TypeManager.IsGenericParameter (itype.GetElementType ())) + if (!TypeManager.IsGenericParameter (TypeManager.GetElementType (itype))) continue; } - type_inference.ExactInference (Parameters.FixedParameters[i].ParameterType, itype); + type_inference.ExactInference (Parameters.Types [i], itype); } return true; } @@ -971,6 +1005,7 @@ namespace Mono.CSharp { if (am == null) return null; + // Stop referencing gmcs NullLiteral type if (am.ReturnType == TypeManager.null_type) am.ReturnType = null; @@ -1020,7 +1055,7 @@ namespace Mono.CSharp { am = CreateExpressionTree (ec, delegate_type); if (!ec.IsInProbingMode) - compatibles.Add (type, am); + compatibles.Add (type, am == null ? EmptyExpression.Null : am); return am; } catch (Exception e) { @@ -1039,19 +1074,19 @@ namespace Mono.CSharp { return null; } - protected virtual Parameters ResolveParameters (EmitContext ec, TypeInferenceContext tic, Type delegate_type) + protected virtual ParametersCompiled ResolveParameters (EmitContext ec, TypeInferenceContext tic, Type delegate_type) { - ParameterData delegate_parameters = TypeManager.GetDelegateParameters (delegate_type); + AParametersCollection delegate_parameters = TypeManager.GetDelegateParameters (delegate_type); - if (Parameters == null) { + if (Parameters == ParametersCompiled.Undefined) { // // We provide a set of inaccessible parameters // Parameter[] fixedpars = new Parameter[delegate_parameters.Count]; for (int i = 0; i < delegate_parameters.Count; i++) { - Parameter.Modifier i_mod = delegate_parameters.ParameterModifier (i); - if ((i_mod & Parameter.Modifier.OUTMASK) != 0) { + Parameter.Modifier i_mod = delegate_parameters.FixedParameters [i].ModFlags; + if (i_mod == Parameter.Modifier.OUT) { Report.Error (1688, loc, "Cannot convert anonymous " + "method block without a parameter list " + "to delegate type `{0}' because it has " + @@ -1060,11 +1095,11 @@ namespace Mono.CSharp { return null; } fixedpars[i] = new Parameter ( - delegate_parameters.ParameterType (i), null, - delegate_parameters.ParameterModifier (i), null, loc); + null, null, + delegate_parameters.FixedParameters [i].ModFlags, null, loc); } - return Parameters.CreateFullyResolved (fixedpars, delegate_parameters.Types); + return ParametersCompiled.CreateFullyResolved (fixedpars, delegate_parameters.Types); } if (!VerifyExplicitParameters (delegate_type, delegate_parameters, ec.IsInProbingMode)) { @@ -1111,6 +1146,13 @@ namespace Mono.CSharp { // nothing, as we only exist to not do anything. } + public static void Error_AddressOfCapturedVar (IVariableReference var, Location loc) + { + Report.Error (1686, loc, + "Local variable or parameter `{0}' cannot have their address taken and be used inside an anonymous method or lambda expression", + var.Name); + } + public override string GetSignatureForError () { return ExprClassName; @@ -1118,7 +1160,7 @@ namespace Mono.CSharp { protected AnonymousMethodBody CompatibleMethod (EmitContext ec, TypeInferenceContext tic, Type return_type, Type delegate_type) { - Parameters p = ResolveParameters (ec, tic, delegate_type); + ParametersCompiled p = ResolveParameters (ec, tic, delegate_type); if (p == null) return null; @@ -1131,7 +1173,7 @@ namespace Mono.CSharp { return anonymous; } - protected virtual AnonymousMethodBody CompatibleMethodFactory (Type return_type, Type delegate_type, Parameters p, ToplevelBlock b) + protected virtual AnonymousMethodBody CompatibleMethodFactory (Type return_type, Type delegate_type, ParametersCompiled p, ToplevelBlock b) { return new AnonymousMethodBody (p, b, return_type, delegate_type, loc); } @@ -1158,9 +1200,9 @@ namespace Mono.CSharp { public AnonymousMethodMethod (DeclSpace parent, AnonymousExpression am, AnonymousMethodStorey storey, GenericMethod generic, TypeExpr return_type, int mod, string real_name, MemberName name, - Parameters parameters) + ParametersCompiled parameters) : base (parent, generic, return_type, mod | Modifiers.COMPILER_GENERATED, - false, name, parameters, null) + name, parameters, null) { this.AnonymousMethod = am; this.Storey = storey; @@ -1178,22 +1220,25 @@ namespace Mono.CSharp { return aec; } - public override bool Define () + protected override bool ResolveMemberType () { - if (Storey != null && Storey.IsGeneric && Storey.HasHoistedVariables) { + if (!base.ResolveMemberType ()) + return false; + + if (Storey != null && Storey.IsGeneric) { AnonymousMethodStorey gstorey = Storey.GetGenericStorey (); if (gstorey != null) { - if (!Parameters.Empty) { + if (!Parameters.IsEmpty) { Type [] ptypes = Parameters.Types; for (int i = 0; i < ptypes.Length; ++i) ptypes [i] = gstorey.MutateType (ptypes [i]); } - member_type = gstorey.MutateType (ReturnType); + member_type = gstorey.MutateType (member_type); } } - return base.Define (); + return true; } public override void Emit () @@ -1211,7 +1256,6 @@ namespace Mono.CSharp { } if (MethodBuilder == null) { - ResolveMembers (); Define (); } @@ -1239,7 +1283,6 @@ namespace Mono.CSharp { this.loc = loc; } - public abstract void AddStoreyReference (AnonymousMethodStorey storey); public abstract string ContainerType { get; } public abstract bool IsIterator { get; } public abstract AnonymousMethodStorey Storey { get; } @@ -1285,16 +1328,33 @@ namespace Mono.CSharp { return res; } + + public void SetHasThisAccess () + { + Block.HasCapturedThis = true; + ExplicitBlock b = Block.Parent.Explicit; + + while (b != null) { + if (b.HasCapturedThis) + return; + + b.HasCapturedThis = true; + b = b.Parent == null ? null : b.Parent.Explicit; + } + } } public class AnonymousMethodBody : AnonymousExpression { - ArrayList referenced_storeys; - protected readonly Parameters parameters; + protected readonly ParametersCompiled parameters; AnonymousMethodStorey storey; + + AnonymousMethodMethod method; + Field am_cache; + static int unique_id; - public AnonymousMethodBody (Parameters parameters, + public AnonymousMethodBody (ParametersCompiled parameters, ToplevelBlock block, Type return_type, Type delegate_type, Location loc) : base (block, return_type, loc) @@ -1315,23 +1375,6 @@ namespace Mono.CSharp { get { return false; } } - // - // Adds new storey reference to track out of scope variables - // - public override void AddStoreyReference (AnonymousMethodStorey storey) - { - if (referenced_storeys == null) { - referenced_storeys = new ArrayList (2); - } else { - foreach (AnonymousMethodStorey ams in referenced_storeys) { - if (ams == storey) - return; - } - } - - referenced_storeys.Add (storey); - } - public override Expression CreateExpressionTree (EmitContext ec) { Report.Error (1945, loc, "An expression tree cannot contain an anonymous method expression"); @@ -1343,35 +1386,9 @@ namespace Mono.CSharp { if (aec == null && !Compatible (ec)) return false; - if (referenced_storeys != null) - ConnectReferencedStoreys (); - return true; } - void ConnectReferencedStoreys () - { - AnonymousMethodStorey storey = FindBestMethodStorey (); - storey.IsParentStoreyUsed = true; - - foreach (AnonymousMethodStorey s in referenced_storeys) { - // - // An anonymous method has to have an instance access when - // children anonymous method requires access to parent storey - // hoisted variables - // - for (Block b = Block.Parent; b != s.OriginalSourceBlock; b = b.Parent) - b.Toplevel.HasStoreyAccess = true; - - if (s == storey) - continue; - - storey.AddParentStoreyReference (s); - s.HasHoistedVariables = true; - Block.Parent.Explicit.PropagateStoreyReference (s); - } - } - // // Creates a host for the anonymous method // @@ -1386,7 +1403,7 @@ namespace Mono.CSharp { // int modifiers; - if (referenced_storeys != null || Block.HasStoreyAccess) { + if (Block.HasCapturedVariable || Block.HasCapturedThis) { storey = FindBestMethodStorey (); modifiers = storey != null ? Modifiers.INTERNAL : Modifiers.PRIVATE; } else { @@ -1407,10 +1424,15 @@ namespace Mono.CSharp { if (storey == null && mc.MemberName.IsGeneric) { member_name = new MemberName (name, mc.MemberName.TypeArguments.Clone (), Location); - generic_method = new GenericMethod ( - parent.NamespaceEntry, parent, member_name, + generic_method = new GenericMethod (parent.NamespaceEntry, parent, member_name, new TypeExpression (ReturnType, Location), parameters); - generic_method.SetParameterInfo (null); + + ArrayList list = new ArrayList (); + foreach (TypeParameter tparam in ((IMethodData)mc).GenericMethod.CurrentTypeParameters) { + if (tparam.Constraints != null) + list.Add (tparam.Constraints.Clone ()); + } + generic_method.SetParameterInfo (list); } else { member_name = new MemberName (name, Location); generic_method = null; @@ -1439,34 +1461,50 @@ namespace Mono.CSharp { public override void Emit (EmitContext ec) { // - // It has to be delayed not to polute expression trees - // - - // - // Don't create anonymous expression method when we are in probing - // mode or unreachable block + // Use same anonymous method implementation for scenarios where same + // code is used from multiple blocks, e.g. field initializers // - // if (ec.IsVariableCapturingRequired) ??? - - AnonymousMethodMethod method = DoCreateMethodHost (ec); - method.ResolveMembers (); - method.Define (); + if (method == null) { + // + // Delay an anonymous method definition to avoid emitting unused code + // for unreachable blocks or expression trees + // + method = DoCreateMethodHost (ec); + method.Define (); + } - Field am_cache = null; bool is_static = (method.ModFlags & Modifiers.STATIC) != 0; - if (is_static) { + if (is_static && am_cache == null) { // - // Creates a field cache to store delegate instance if it's not generic or all - // type arguments are closed + // Creates a field cache to store delegate instance if it's not generic // - if (!method.MemberName.IsGeneric || !HasGenericTypeParameter (type)) { + if (!method.MemberName.IsGeneric) { TypeContainer parent = method.Parent.PartialContainer; int id = parent.Fields == null ? 0 : parent.Fields.Count; am_cache = new Field (parent, new TypeExpression (type, loc), Modifiers.STATIC | Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED, - CompilerGeneratedClass.MakeName (null, "f", "am$cache", id), null, loc); + new MemberName (CompilerGeneratedClass.MakeName (null, "f", "am$cache", id), loc), null); am_cache.Define (); parent.AddField (am_cache); + } else { + // TODO: Implement caching of generated generic static methods + // + // Idea: + // + // Some extra class is needed to capture variable generic type + // arguments. Maybe we could re-use anonymous types, with a unique + // anonymous method id, but they are quite heavy. + // + // Consider : "() => typeof(T);" + // + // We need something like + // static class Wrap { + // public static DelegateType cache; + // } + // + // We then specialize local variable to capture all generic parameters + // and delegate type, e.g. "Wrap cache;" + // } } @@ -1493,11 +1531,26 @@ namespace Mono.CSharp { } MethodInfo delegate_method = method.MethodBuilder; -#if GMCS_SOURCE if (storey != null && storey.MemberName.IsGeneric) { - delegate_method = TypeBuilder.GetMethod (Storey.Instance.Type, delegate_method); - } + Type t = storey.Instance.Type; + + // + // Mutate anonymous method instance type if we are in nested + // hoisted generic anonymous method storey + // + if (ec.CurrentAnonymousMethod != null && + ec.CurrentAnonymousMethod.Storey != null && + ec.CurrentAnonymousMethod.Storey.IsGeneric) { + t = storey.GetGenericStorey ().MutateType (t); + } + +#if GMCS_SOURCE + delegate_method = TypeBuilder.GetMethod (t, delegate_method); +#else + throw new NotSupportedException (); #endif + } + ig.Emit (OpCodes.Ldftn, delegate_method); ConstructorInfo constructor_method = Delegate.GetConstructor (ec.ContainerType, type); @@ -1536,36 +1589,11 @@ namespace Mono.CSharp { return TypeManager.CSharpName (type); } - static bool HasGenericTypeParameter (Type type) - { -#if GMCS_SOURCE - if (type.IsGenericParameter) - return true; - - if (!type.IsGenericType) - return false; - - foreach (Type t in type.GetGenericArguments ()) { - if (HasGenericTypeParameter (t)) - return true; - } -#endif - return false; - } - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) { type = storey.MutateType (type); } - public static void Error_AddressOfCapturedVar (string name, Location loc) - { - Report.Error (1686, loc, - "Local variable `{0}' or its members cannot have their " + - "address taken and be used inside an anonymous method block", - name); - } - public static void Reset () { unique_id = 0; @@ -1577,6 +1605,20 @@ namespace Mono.CSharp { // public class AnonymousTypeClass : CompilerGeneratedClass { + sealed class AnonymousParameters : ParametersCompiled + { + public AnonymousParameters (params Parameter[] parameters) + : base (parameters) + { + } + + protected override void ErrorDuplicateName (Parameter p) + { + Report.Error (833, p.Location, "`{0}': An anonymous type cannot have multiple properties with the same name", + p.Name); + } + } + static int types_counter; public const string ClassNamePrefix = "<>__AnonType"; public const string SignatureForError = "anonymous type"; @@ -1584,7 +1626,7 @@ namespace Mono.CSharp { readonly ArrayList parameters; private AnonymousTypeClass (DeclSpace parent, MemberName name, ArrayList parameters, Location loc) - : base (parent, name, Modifiers.SEALED) + : base (parent, name, (RootContext.EvalMode ? Modifiers.PUBLIC : 0) | Modifiers.SEALED) { this.parameters = parameters; } @@ -1597,11 +1639,13 @@ namespace Mono.CSharp { string name = ClassNamePrefix + types_counter++; SimpleName [] t_args = new SimpleName [parameters.Count]; + TypeParameterName [] t_params = new TypeParameterName [parameters.Count]; Parameter [] ctor_params = new Parameter [parameters.Count]; for (int i = 0; i < parameters.Count; ++i) { AnonymousTypeParameter p = (AnonymousTypeParameter) parameters [i]; t_args [i] = new SimpleName ("<" + p.Name + ">__T", p.Location); + t_params [i] = new TypeParameterName (t_args [i].Name, null, p.Location); ctor_params [i] = new Parameter (t_args [i], p.Name, 0, null, p.Location); } @@ -1610,13 +1654,13 @@ namespace Mono.CSharp { // named upon properties names // AnonymousTypeClass a_type = new AnonymousTypeClass (parent.NamespaceEntry.SlaveDeclSpace, - new MemberName (name, new TypeArguments (loc, t_args), loc), parameters, loc); + new MemberName (name, new TypeArguments (t_params), loc), parameters, loc); if (parameters.Count > 0) a_type.SetParameterInfo (null); Constructor c = new Constructor (a_type, name, Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN, - new Parameters (ctor_params), null, loc); + null, new AnonymousParameters (ctor_params), null, loc); c.Block = new ToplevelBlock (c.Parameters, loc); // @@ -1627,12 +1671,10 @@ namespace Mono.CSharp { AnonymousTypeParameter p = (AnonymousTypeParameter) parameters [i]; Field f = new Field (a_type, t_args [i], Modifiers.PRIVATE | Modifiers.READONLY, - "<" + p.Name + ">", null, p.Location); + new MemberName ("<" + p.Name + ">", p.Location), null); if (!a_type.AddField (f)) { error = true; - Report.Error (833, p.Location, "`{0}': An anonymous type cannot have multiple properties with the same name", - p.Name); continue; } @@ -1643,8 +1685,8 @@ namespace Mono.CSharp { ToplevelBlock get_block = new ToplevelBlock (p.Location); get_block.AddStatement (new Return ( new MemberAccess (new This (p.Location), f.Name), p.Location)); - Accessor get_accessor = new Accessor (get_block, 0, null, p.Location); - Property prop = new Property (a_type, t_args [i], Modifiers.PUBLIC, false, + Accessor get_accessor = new Accessor (get_block, 0, null, null, p.Location); + Property prop = new Property (a_type, t_args [i], Modifiers.PUBLIC, new MemberName (p.Name, p.Location), null, get_accessor, null, false); a_type.AddProperty (prop); } @@ -1679,17 +1721,17 @@ namespace Mono.CSharp { Location loc = Location; Method equals = new Method (this, null, TypeManager.system_boolean_expr, - Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, false, new MemberName ("Equals", loc), - new Parameters (new Parameter (TypeManager.system_object_expr, "obj", 0, null, loc)), null); + Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, new MemberName ("Equals", loc), + Mono.CSharp.ParametersCompiled.CreateFullyResolved (new Parameter (null, "obj", 0, null, loc), TypeManager.object_type), null); Method tostring = new Method (this, null, TypeManager.system_string_expr, - Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, false, new MemberName ("ToString", loc), - Mono.CSharp.Parameters.EmptyReadOnlyParameters, null); + Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, new MemberName ("ToString", loc), + Mono.CSharp.ParametersCompiled.EmptyReadOnlyParameters, null); ToplevelBlock equals_block = new ToplevelBlock (equals.Parameters, loc); TypeExpr current_type; if (IsGeneric) - current_type = new ConstructedType (TypeBuilder, TypeParameters, loc); + current_type = new GenericTypeExpr (this, loc); else current_type = new TypeExpression (TypeBuilder, loc); @@ -1700,7 +1742,7 @@ namespace Mono.CSharp { new QualifiedAliasMember ("global", "System", loc), "Collections", loc), "Generic", loc); Expression rs_equals = null; - Expression string_concat = new StringConstant ("", loc); + Expression string_concat = new StringConstant ("{", loc); Expression rs_hashcode = new IntConstant (-2128831035, loc); for (int i = 0; i < parameters.Count; ++i) { AnonymousTypeParameter p = (AnonymousTypeParameter) parameters [i]; @@ -1708,7 +1750,7 @@ namespace Mono.CSharp { MemberAccess equality_comparer = new MemberAccess (new MemberAccess ( system_collections_generic, "EqualityComparer", - new TypeArguments (loc, new SimpleName (TypeParameters [i].Name, loc)), loc), + new TypeArguments (new SimpleName (TypeParameters [i].Name, loc)), loc), "Default", loc); ArrayList arguments_equal = new ArrayList (2); @@ -1732,13 +1774,15 @@ namespace Mono.CSharp { new MemberAccess (new This (f.Location), f.Name), new NullLiteral (loc)), new Invocation (new MemberAccess ( new MemberAccess (new This (f.Location), f.Name), "ToString"), null), - new StringConstant ("", loc)); + new StringConstant (string.Empty, loc)); if (rs_equals == null) { rs_equals = field_equal; string_concat = new Binary (Binary.Operator.Addition, - new StringConstant (p.Name + " = ", loc), - field_to_string); + string_concat, + new Binary (Binary.Operator.Addition, + new StringConstant (" " + p.Name + " = ", loc), + field_to_string)); continue; } @@ -1754,6 +1798,10 @@ namespace Mono.CSharp { rs_equals = new Binary (Binary.Operator.LogicalAnd, rs_equals, field_equal); } + string_concat = new Binary (Binary.Operator.Addition, + string_concat, + new StringConstant (" }", loc)); + // // Equals (object obj) override // @@ -1768,7 +1816,7 @@ namespace Mono.CSharp { equals_block.AddStatement (new Return (equals_test, loc)); equals.Block = equals_block; - equals.ResolveMembers (); + equals.Define (); AddMethod (equals); // @@ -1776,8 +1824,8 @@ namespace Mono.CSharp { // Method hashcode = new Method (this, null, TypeManager.system_int32_expr, Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, - false, new MemberName ("GetHashCode", loc), - Mono.CSharp.Parameters.EmptyReadOnlyParameters, null); + new MemberName ("GetHashCode", loc), + Mono.CSharp.ParametersCompiled.EmptyReadOnlyParameters, null); // // Modified FNV with good avalanche behavior and uniform @@ -1793,7 +1841,10 @@ namespace Mono.CSharp { // hash ^= hash >> 17; // hash += hash << 5; - ToplevelBlock hashcode_block = new ToplevelBlock (loc); + ToplevelBlock hashcode_top = new ToplevelBlock (loc); + Block hashcode_block = new Block (hashcode_top); + hashcode_top.AddStatement (new Unchecked (hashcode_block)); + hashcode_block.AddVariable (TypeManager.system_int32_expr, "hash", loc); LocalVariableReference hash_variable = new LocalVariableReference (hashcode_block, "hash", loc); hashcode_block.AddStatement (new StatementExpression ( @@ -1816,8 +1867,8 @@ namespace Mono.CSharp { new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (5, loc))))); hashcode_block.AddStatement (new Return (hash_variable, loc)); - hashcode.Block = hashcode_block; - hashcode.ResolveMembers (); + hashcode.Block = hashcode_top; + hashcode.Define (); AddMethod (hashcode); // @@ -1827,15 +1878,17 @@ namespace Mono.CSharp { ToplevelBlock tostring_block = new ToplevelBlock (loc); tostring_block.AddStatement (new Return (string_concat, loc)); tostring.Block = tostring_block; - tostring.ResolveMembers (); + tostring.Define (); AddMethod (tostring); } - public override bool DefineMembers () + public override bool Define () { - DefineOverrides (); + if (!base.Define ()) + return false; - return base.DefineMembers (); + DefineOverrides (); + return true; } public override string GetSignatureForError ()