X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fclass.cs;h=980b6858a1c92377bcd1e881dbe5201bc19f59ff;hb=a651e64e7518044338d18ea58952d2ed7ca6f5bd;hp=3659320ee7bee3613970af6eaf92f8c1d32cf41c;hpb=5c227da87d62dff13f003485ae1dd8830c29aad4;p=mono.git diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs index 3659320ee7b..980b6858a1c 100644 --- a/mcs/mcs/class.cs +++ b/mcs/mcs/class.cs @@ -10,26 +10,7 @@ // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com) // Copyright 2004-2008 Novell, Inc // -// -// 2002-10-11 Miguel de Icaza -// -// * class.cs: Following the comment from 2002-09-26 to AddMethod, I -// have fixed a remaining problem: not every AddXXXX was adding a -// fully qualified name. -// -// Now everyone registers a fully qualified name in the DeclSpace as -// being defined instead of the partial name. -// -// Downsides: we are slower than we need to be due to the excess -// copies and the names being registered this way. -// -// The reason for this is that we currently depend (on the corlib -// bootstrap for instance) that types are fully qualified, because -// we dump all the types in the namespace, and we should really have -// types inserted into the proper namespace, so we can only store the -// basenames in the defined_names array. -// -// + using System; using System.Collections; using System.Collections.Specialized; @@ -173,6 +154,46 @@ namespace Mono.CSharp { } } + // + // Different context is needed when resolving type container base + // types. Type names come from the parent scope but type parameter + // names from the container scope. + // + struct BaseContext : IResolveContext + { + TypeContainer tc; + + public BaseContext (TypeContainer tc) + { + this.tc = tc; + } + + #region IResolveContext Members + + public DeclSpace DeclContainer { + get { return tc.Parent; } + } + + public bool IsInObsoleteScope { + get { return tc.IsInObsoleteScope; } + } + + public bool IsInUnsafeScope { + get { return tc.IsInUnsafeScope; } + } + + public FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104) + { + return tc.Parent.LookupNamespaceOrType (name, loc, ignore_cs0104); + } + + public DeclSpace GenericDeclContainer { + get { return tc.GenericDeclContainer; } + } + + #endregion + } + [Flags] enum CachedMethods { @@ -201,7 +222,7 @@ namespace Mono.CSharp { protected MemberCoreArrayList instance_constructors; // Holds the list of fields - MemberCoreArrayList fields; + protected MemberCoreArrayList fields; // Holds a list of fields that have initializers protected ArrayList initialized_fields; @@ -248,11 +269,10 @@ namespace Mono.CSharp { TypeExpr base_type; TypeExpr[] iface_exprs; Type GenericType; + GenericTypeParameterBuilder[] nested_gen_params; protected ArrayList type_bases; - bool members_resolved; - bool members_resolved_ok; protected bool members_defined; bool members_defined_ok; @@ -267,6 +287,7 @@ namespace Mono.CSharp { private bool seen_normal_indexers = false; private string indexer_name = DefaultIndexerName; + protected bool requires_delayed_unmanagedtype_check; private CachedMethods cached_method; @@ -291,7 +312,7 @@ namespace Mono.CSharp { public bool AddMember (MemberCore symbol) { - return AddToContainer (symbol, symbol.MemberName.MethodName); + return AddToContainer (symbol, symbol.MemberName.Basename); } protected virtual bool AddMemberType (DeclSpace ds) @@ -299,6 +320,11 @@ namespace Mono.CSharp { return AddToContainer (ds, ds.Basename); } + protected virtual void RemoveMemberType (DeclSpace ds) + { + RemoveFromContainer (ds.Basename); + } + public void AddConstant (Const constant) { if (!AddMember (constant)) @@ -380,6 +406,13 @@ namespace Mono.CSharp { return tc; } + public virtual void RemoveTypeContainer (TypeContainer next_part) + { + if (types != null) + types.Remove (next_part); + RemoveMemberType (next_part); + } + public void AddDelegate (Delegate d) { if (!AddMemberType (d)) @@ -414,10 +447,9 @@ namespace Mono.CSharp { } - public void AddMethod (Method method) + public void AddMethod (MethodOrOperator method) { - MemberName mn = method.MemberName; - if (!AddToContainer (method, mn.IsGeneric ? mn.Basename : mn.MethodName)) + if (!AddToContainer (method, method.MemberName.Basename)) return; if (methods == null) @@ -431,16 +463,12 @@ namespace Mono.CSharp { public void AddConstructor (Constructor c) { - if (c.Name != MemberName.Name) { - Report.Error (1520, c.Location, "Class, struct, or interface method must have a return type"); - } - bool is_static = (c.ModFlags & Modifiers.STATIC) != 0; if (!AddToContainer (c, is_static ? ConstructorBuilder.ConstructorName : ConstructorBuilder.TypeConstructorName)) return; - if (is_static && c.Parameters.Empty){ + if (is_static && c.Parameters.IsEmpty){ if (default_static_constructor != null) { Report.SymbolRelatedToPreviousError (default_static_constructor); Report.Error (111, c.Location, @@ -451,7 +479,7 @@ namespace Mono.CSharp { default_static_constructor = c; } else { - if (c.Parameters.Empty) + if (c.Parameters.IsEmpty) default_constructor = c; if (instance_constructors == null) @@ -557,16 +585,16 @@ namespace Mono.CSharp { compiler_generated.Add (c); } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.default_member_type) { + if (a.Type == pa.DefaultMember) { if (Indexers != null) { Report.Error (646, a.Location, "Cannot specify the `DefaultMember' attribute on type containing an indexer"); return; } } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } public override AttributeTargets AttributeTargets { @@ -655,10 +683,10 @@ namespace Mono.CSharp { public bool IsComImport { get { - if (OptAttributes == null || TypeManager.comimport_attr_type == null) + if (OptAttributes == null) return false; - return OptAttributes.Contains (TypeManager.comimport_attr_type); + return OptAttributes.Contains (PredefinedAttributes.Get.ComImport); } } @@ -681,19 +709,12 @@ namespace Mono.CSharp { public void ResolveFieldInitializers (EmitContext ec) { - // Field initializers are tricky for partial classes. They have to - // share same costructor (block) but they have they own resolve scope. - DeclSpace orig = ec.DeclContainer; - if (partial_parts != null) { foreach (TypeContainer part in partial_parts) { - ec.DeclContainer = part; part.DoResolveFieldInitializers (ec); } } - ec.DeclContainer = PartialContainer; DoResolveFieldInitializers (ec); - ec.DeclContainer = orig; } void DoResolveFieldInitializers (EmitContext ec) @@ -702,28 +723,32 @@ namespace Mono.CSharp { if (initialized_static_fields == null) return; - bool has_complex_initializer = false; - using (ec.Set (EmitContext.Flags.InFieldInitializer)) { - foreach (FieldInitializer fi in initialized_static_fields) { - fi.ResolveStatement (ec); - if (!fi.IsComplexInitializer) - continue; - - has_complex_initializer = true; + bool has_complex_initializer = !RootContext.Optimize; + int i; + ExpressionStatement [] init = new ExpressionStatement [initialized_static_fields.Count]; + for (i = 0; i < initialized_static_fields.Count; ++i) { + FieldInitializer fi = (FieldInitializer) initialized_static_fields [i]; + ExpressionStatement s = fi.ResolveStatement (ec); + if (s == null) { + s = EmptyExpressionStatement.Instance; + } else if (fi.IsComplexInitializer) { + has_complex_initializer |= true; } + init [i] = s; + } + + for (i = 0; i < initialized_static_fields.Count; ++i) { + FieldInitializer fi = (FieldInitializer) initialized_static_fields [i]; + // // Need special check to not optimize code like this // static int a = b = 5; // static int b = 0; - if (!has_complex_initializer && RootContext.Optimize) { - for (int i = 0; i < initialized_static_fields.Count; ++i) { - FieldInitializer fi = (FieldInitializer) initialized_static_fields [i]; - if (fi.IsDefaultInitializer) { - initialized_static_fields.RemoveAt (i); - --i; - } - } - } + // + if (!has_complex_initializer && fi.IsDefaultInitializer) + continue; + + ec.CurrentBlock.AddScopeStatement (new StatementExpression (init [i])); } return; @@ -732,46 +757,22 @@ namespace Mono.CSharp { if (initialized_fields == null) return; - using (ec.Set (EmitContext.Flags.InFieldInitializer)) { - for (int i = 0; i < initialized_fields.Count; ++i) { - FieldInitializer fi = (FieldInitializer) initialized_fields [i]; - fi.ResolveStatement (ec); - if (fi.IsDefaultInitializer && RootContext.Optimize) { - // Field is re-initialized to its default value => removed - initialized_fields.RemoveAt (i); - --i; - } - } - } - } - - // - // Emits the instance field initializers - // - public bool EmitFieldInitializers (EmitContext ec) - { - if (partial_parts != null) { - foreach (TypeContainer part in partial_parts) - part.EmitFieldInitializers (ec); - } - - ArrayList fields; - - if (ec.IsStatic){ - fields = initialized_static_fields; - } else { - fields = initialized_fields; - } + for (int i = 0; i < initialized_fields.Count; ++i) { + FieldInitializer fi = (FieldInitializer) initialized_fields [i]; + ExpressionStatement s = fi.ResolveStatement (ec); + if (s == null) + continue; - if (fields == null) - return true; + // + // Field is re-initialized to its default value => removed + // + if (fi.IsDefaultInitializer && RootContext.Optimize) + continue; - foreach (FieldInitializer f in fields) { - f.EmitStatement (ec); + ec.CurrentBlock.AddScopeStatement (new StatementExpression (s)); } - return true; } - + public override string DocComment { get { return comment; @@ -803,45 +804,82 @@ namespace Mono.CSharp { ((TypeContainer) part).type_bases = bases; } - TypeExpr[] GetNormalBases (out TypeExpr base_class) + /// + /// This function computes the Base class and also the + /// list of interfaces that the class or struct @c implements. + /// + /// The return value is an array (might be null) of + /// interfaces implemented (as Types). + /// + /// The @base_class argument is set to the base object or null + /// if this is `System.Object'. + /// + protected virtual TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { base_class = null; if (type_bases == null) return null; int count = type_bases.Count; - int start = 0, i, j; + TypeExpr [] ifaces = null; + IResolveContext base_context = new BaseContext (this); + for (int i = 0, j = 0; i < count; i++){ + FullNamedExpression fne = (FullNamedExpression) type_bases [i]; - if (Kind == Kind.Class){ - TypeExpr name = ((Expression) type_bases [0]).ResolveAsBaseTerminal (this, false); + // + // Standard ResolveAsTypeTerminal cannot be used in this case because + // it does ObsoleteAttribute and constraint checks which require + // base type to be set + // + TypeExpr fne_resolved = fne.ResolveAsBaseTerminal (base_context, false); + if (fne_resolved == null) + continue; - if (name == null){ - return null; + if (i == 0 && Kind == Kind.Class && !fne_resolved.Type.IsInterface) { + if (fne_resolved is DynamicTypeExpr) + Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type", + GetSignatureForError ()); + else + base_class = fne_resolved; + continue; } - if (!name.IsInterface) { - // base_class could be a class, struct, enum, delegate. - // This is validated in GetClassBases. - base_class = name; - start = 1; - } - } + if (ifaces == null) + ifaces = new TypeExpr [count - i]; + + if (fne_resolved.Type.IsInterface) { + for (int ii = 0; ii < j; ++ii) { + if (TypeManager.IsEqual (fne_resolved.Type, ifaces [ii].Type)) { + Report.Error (528, Location, "`{0}' is already listed in interface list", + fne_resolved.GetSignatureForError ()); + break; + } + } - TypeExpr [] ifaces = new TypeExpr [count-start]; - - for (i = start, j = 0; i < count; i++, j++){ - TypeExpr resolved = ((Expression) type_bases [i]).ResolveAsBaseTerminal (this, false); - if (resolved == null) { - return null; + if (Kind == Kind.Interface && !IsAccessibleAs (fne_resolved.Type)) { + Report.Error (61, fne.Location, + "Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'", + fne_resolved.GetSignatureForError (), GetSignatureForError ()); + } + } else { + Report.SymbolRelatedToPreviousError (fne_resolved.Type); + if (Kind != Kind.Class) { + Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ()); + } else if (base_class != null) + Report.Error (1721, fne.Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')", + GetSignatureForError (), base_class.GetSignatureForError (), fne_resolved.GetSignatureForError ()); + else { + Report.Error (1722, fne.Location, "`{0}': Base class `{1}' must be specified as first", + GetSignatureForError (), fne_resolved.GetSignatureForError ()); + } } - - ifaces [j] = resolved; + + ifaces [j++] = fne_resolved; } - return ifaces.Length == 0 ? null : ifaces; + return ifaces; } - TypeExpr[] GetNormalPartialBases (ref TypeExpr base_class) { ArrayList ifaces = new ArrayList (0); @@ -850,7 +888,7 @@ namespace Mono.CSharp { foreach (TypeContainer part in partial_parts) { TypeExpr new_base_class; - TypeExpr[] new_ifaces = part.GetClassBases (out new_base_class); + TypeExpr[] new_ifaces = part.ResolveBaseTypes (out new_base_class); if (new_base_class != TypeManager.system_object_expr) { if (base_class == TypeManager.system_object_expr) base_class = new_base_class; @@ -883,65 +921,6 @@ namespace Mono.CSharp { return (TypeExpr[])ifaces.ToArray (typeof (TypeExpr)); } - /// - /// This function computes the Base class and also the - /// list of interfaces that the class or struct @c implements. - /// - /// The return value is an array (might be null) of - /// interfaces implemented (as Types). - /// - /// The @base_class argument is set to the base object or null - /// if this is `System.Object'. - /// - public virtual TypeExpr [] GetClassBases (out TypeExpr base_class) - { - TypeExpr[] ifaces = GetNormalBases (out base_class); - - if (ifaces == null) - return null; - - int count = ifaces.Length; - - for (int i = 0; i < count; i++) { - TypeExpr iface = (TypeExpr) ifaces [i]; - - if (!iface.IsInterface) { - if (Kind != Kind.Class) { - // TODO: location of symbol related .... - Error_TypeInListIsNotInterface (Location, iface.GetSignatureForError ()); - } - else if (base_class != null) - Report.Error (1721, Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')", - GetSignatureForError (), base_class.GetSignatureForError (), iface.GetSignatureForError ()); - else { - Report.Error (1722, Location, "`{0}': Base class `{1}' must be specified as first", - GetSignatureForError (), iface.GetSignatureForError ()); - } - return null; - } - - for (int x = 0; x < i; x++) { - if (iface.Equals (ifaces [x])) { - Report.Error (528, Location, - "`{0}' is already listed in " + - "interface list", iface.GetSignatureForError ()); - return null; - } - } - - if ((Kind == Kind.Interface) && - !iface.AsAccessible (this)) { - Report.Error (61, Location, - "Inconsistent accessibility: base " + - "interface `{0}' is less accessible " + - "than interface `{1}'", iface.GetSignatureForError (), - Name); - return null; - } - } - return ifaces; - } - bool CheckGenericInterfaces (Type[] ifaces) { #if GMCS_SOURCE @@ -974,11 +953,6 @@ namespace Mono.CSharp { bool error = false; - protected void Error_TypeInListIsNotInterface (Location loc, string type) - { - Report.Error (527, loc, "Type `{0}' in interface list is not an interface", type); - } - bool CreateTypeBuilder () { try { @@ -998,7 +972,7 @@ namespace Mono.CSharp { return false; } - ModuleBuilder builder = CodeGen.Module.Builder; + ModuleBuilder builder = Module.Builder; TypeBuilder = builder.DefineType ( Name, TypeAttr, default_parent, type_size); } else { @@ -1014,26 +988,34 @@ namespace Mono.CSharp { TypeManager.AddUserType (this); -#if GMCS_SOURCE if (IsGeneric) { string[] param_names = new string [TypeParameters.Length]; for (int i = 0; i < TypeParameters.Length; i++) param_names [i] = TypeParameters [i].Name; +#if GMCS_SOURCE GenericTypeParameterBuilder[] gen_params = TypeBuilder.DefineGenericParameters (param_names); int offset = CountTypeParameters - CurrentTypeParameters.Length; + if (offset > 0) { + nested_gen_params = new GenericTypeParameterBuilder [offset]; + Array.Copy (gen_params, nested_gen_params, offset); + } + for (int i = offset; i < gen_params.Length; i++) CurrentTypeParameters [i - offset].Define (gen_params [i]); - } +#else + nested_gen_params = null; + throw new NotSupportedException (); #endif + } return true; } bool DefineBaseTypes () { - iface_exprs = GetClassBases (out base_type); + iface_exprs = ResolveBaseTypes (out base_type); if (partial_parts != null) { iface_exprs = GetNormalPartialBases (ref base_type); } @@ -1051,22 +1033,11 @@ namespace Mono.CSharp { if (!(this is CompilerGeneratedClass)) RootContext.RegisterOrder (this); - if (IsGeneric && base_type != null && TypeManager.IsAttributeType (base_type.Type)) { - Report.Error (698, base_type.Location, - "A generic type cannot derive from `{0}' because it is an attribute class", - base_type.GetSignatureForError ()); - return false; - } - if (!CheckRecursiveDefinition (this)) return false; if (base_type != null && base_type.Type != null) { TypeBuilder.SetParent (base_type.Type); - - ObsoleteAttribute obsolete_attr = AttributeTester.GetObsoleteAttribute (base_type.Type); - if (obsolete_attr != null && !IsInObsoleteScope) - AttributeTester.Report_ObsoleteMessage (obsolete_attr, base_type.GetSignatureForError (), Location); } // add interfaces that were not added at type creation @@ -1078,13 +1049,6 @@ namespace Mono.CSharp { foreach (Type itype in ifaces) TypeBuilder.AddInterfaceImplementation (itype); - foreach (TypeExpr ie in iface_exprs) { - ObsoleteAttribute oa = AttributeTester.GetObsoleteAttribute (ie.Type); - if ((oa != null) && !IsInObsoleteScope) - AttributeTester.Report_ObsoleteMessage ( - oa, ie.GetSignatureForError (), Location); - } - if (!CheckGenericInterfaces (ifaces)) return false; @@ -1148,11 +1112,6 @@ namespace Mono.CSharp { return null; } - if (!ResolveMembers ()) { - error = true; - return null; - } - if (!DefineNestedTypes ()) { error = true; return null; @@ -1161,37 +1120,6 @@ namespace Mono.CSharp { return TypeBuilder; } - bool ResolveMembers () - { - if (members_resolved) - return members_resolved_ok; - - members_resolved_ok = DoResolveMembers (); - members_resolved = true; - - return members_resolved_ok; - } - - protected virtual bool DoResolveMembers () - { - if (methods != null) { - foreach (Method method in methods) { - if (!method.ResolveMembers ()) - return false; - } - } - - // TODO: this is not really needed - if (operators != null) { - foreach (Operator o in operators) { - if (!o.ResolveMembers ()) - return false; - } - } - - return true; - } - public override void SetParameterInfo (ArrayList constraints_list) { base.SetParameterInfo (constraints_list); @@ -1244,12 +1172,6 @@ namespace Mono.CSharp { protected virtual bool DoResolveType () { - if ((base_type != null) && - (base_type.ResolveAsTypeTerminal (this, false) == null)) { - error = true; - return false; - } - if (!IsGeneric) return true; @@ -1270,31 +1192,32 @@ namespace Mono.CSharp { UpdateTypeParameterConstraints (part); } - foreach (TypeParameter type_param in TypeParameters) { - if (!type_param.DefineType (this)) { - error = true; - return false; + for (int i = 0; i < TypeParameters.Length; ++i) { + // + // FIXME: Same should be done for delegates + // TODO: Quite ugly way how to propagate constraints to + // nested types + // + if (nested_gen_params != null && i < nested_gen_params.Length) { + TypeParameters [i].SetConstraints (nested_gen_params [i]); + } else { + if (!TypeParameters [i].DefineType (this)) { + error = true; + return false; + } } } - current_type = new ConstructedType (TypeBuilder, TypeParameters, Location); - - foreach (TypeParameter type_param in TypeParameters) - if (!type_param.CheckDependencies ()) { - error = true; - return false; - } - - if (current_type != null) { - current_type = current_type.ResolveAsTypeTerminal (this, false); - if (current_type == null) { - error = true; - return false; - } - - CurrentType = current_type.Type; + // TODO: Very strange, why not simple make generic type from + // current type parameters + current_type = new GenericTypeExpr (this, Location); + current_type = current_type.ResolveAsTypeTerminal (this, false); + if (current_type == null) { + error = true; + return false; } + CurrentType = current_type.Type; return true; } @@ -1359,22 +1282,14 @@ namespace Mono.CSharp { return true; } - public static void Error_KeywordNotAllowed (Location loc) - { - Report.Error (1530, loc, "Keyword `new' is not allowed on namespace elements"); - } - /// /// Populates our TypeBuilder with fields and methods /// - public override bool DefineMembers () + public override bool Define () { if (members_defined) return members_defined_ok; - if (!base.DefineMembers ()) - return false; - members_defined_ok = DoDefineMembers (); members_defined = true; @@ -1385,17 +1300,35 @@ namespace Mono.CSharp { { if (iface_exprs != null) { foreach (TypeExpr iface in iface_exprs) { - ConstructedType ct = iface as ConstructedType; - if ((ct != null) && !ct.CheckConstraints (this)) - return false; + ObsoleteAttribute oa = AttributeTester.GetObsoleteAttribute (iface.Type); + if ((oa != null) && !IsInObsoleteScope) + AttributeTester.Report_ObsoleteMessage ( + oa, iface.GetSignatureForError (), Location); + + GenericTypeExpr ct = iface as GenericTypeExpr; + if (ct != null) { + // TODO: passing `this' is wrong, should be base type iface instead + TypeManager.CheckTypeVariance (ct.Type, Variance.Covariant, this); + + if (!ct.CheckConstraints (this)) + return false; + } } } if (base_type != null) { - ConstructedType ct = base_type as ConstructedType; + ObsoleteAttribute obsolete_attr = AttributeTester.GetObsoleteAttribute (base_type.Type); + if (obsolete_attr != null && !IsInObsoleteScope) + AttributeTester.Report_ObsoleteMessage (obsolete_attr, base_type.GetSignatureForError (), Location); + + GenericTypeExpr ct = base_type as GenericTypeExpr; if ((ct != null) && !ct.CheckConstraints (this)) return false; + TypeContainer baseContainer = TypeManager.LookupTypeContainer(base_type.Type); + if (baseContainer != null) + baseContainer.Define(); + member_cache = new MemberCache (base_type.Type, this); } else if (Kind == Kind.Interface) { member_cache = new MemberCache (null, this); @@ -1438,6 +1371,14 @@ namespace Mono.CSharp { if (Kind == Kind.Struct || Kind == Kind.Class) { pending = PendingImplementation.GetPendingImplementations (this); + + if (requires_delayed_unmanagedtype_check) { + requires_delayed_unmanagedtype_check = false; + foreach (FieldBase f in fields) { + if (f.MemberType != null && f.MemberType.IsPointer) + TypeManager.VerifyUnManaged (f.MemberType, f.Location); + } + } } // @@ -1459,15 +1400,13 @@ namespace Mono.CSharp { GenericType = CurrentType; } -#if GMCS_SOURCE // // FIXME: This hack is needed because member cache does not work // with generic types, we rely on runtime to inflate dynamic types. // TODO: This hack requires member cache refactoring to be removed // - if (TypeBuilder.IsGenericType) + if (TypeManager.IsGenericType (TypeBuilder)) member_cache = new MemberCache (this); -#endif return true; } @@ -1519,23 +1458,12 @@ namespace Mono.CSharp { if (!seen_normal_indexers) return; - if (TypeManager.default_member_ctor == null) { - if (TypeManager.default_member_type == null) { - TypeManager.default_member_type = TypeManager.CoreLookupType ( - "System.Reflection", "DefaultMemberAttribute", Kind.Class, true); - - if (TypeManager.default_member_type == null) - return; - } - - TypeManager.default_member_ctor = TypeManager.GetPredefinedConstructor ( - TypeManager.default_member_type, Location, TypeManager.string_type); - - if (TypeManager.default_member_ctor == null) - return; - } + PredefinedAttribute pa = PredefinedAttributes.Get.DefaultMember; + if (pa.Constructor == null && + !pa.ResolveConstructor (Location, TypeManager.string_type)) + return; - CustomAttributeBuilder cb = new CustomAttributeBuilder (TypeManager.default_member_ctor, new string [] { IndexerName }); + CustomAttributeBuilder cb = new CustomAttributeBuilder (pa.Constructor, new string [] { IndexerName }); TypeBuilder.SetCustomAttribute (cb); } @@ -1549,12 +1477,6 @@ namespace Mono.CSharp { } } - public override bool Define () - { - CheckProtectedModifier (); - return true; - } - public MemberInfo FindBaseMemberWithSameName (string name, bool ignore_methods) { return BaseCache == null ? null : BaseCache.FindMemberWithSameName (name, ignore_methods, null); @@ -1584,7 +1506,7 @@ namespace Mono.CSharp { { ArrayList members = new ArrayList (); - DefineMembers (); + Define (); if (methods != null) { int len = methods.Count; @@ -1651,6 +1573,11 @@ namespace Mono.CSharp { set { caching_flags |= Flags.HasExplicitLayout; } } + public bool HasStructLayout { + get { return (caching_flags & Flags.HasStructLayout) != 0; } + set { caching_flags |= Flags.HasStructLayout; } + } + // // Return the nested type with name @name. Ensures that the nested type // is defined if necessary. Do _not_ use this when you have a MemberCache handy. @@ -1819,7 +1746,7 @@ namespace Mono.CSharp { if (methods != null) { int len = methods.Count; for (int i = 0; i < len; i++) { - Method m = (Method) methods [i]; + MethodOrOperator m = (MethodOrOperator) methods [i]; if ((m.ModFlags & modflags) == 0) continue; @@ -2020,7 +1947,7 @@ namespace Mono.CSharp { if (cb != null && filter (cb, criteria) == true) { if (members == null) members = new ArrayList (); - + members.Add (cb); } } @@ -2148,6 +2075,12 @@ namespace Mono.CSharp { if ((f.caching_flags & Flags.IsAssigned) != 0) continue; + + // + // Don't be pendatic over serializable attributes + // + if (f.OptAttributes != null || PartialContainer.HasStructLayout) + continue; Constant c = New.Constantify (f.MemberType); Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value `{1}'", @@ -2235,7 +2168,7 @@ namespace Mono.CSharp { if (methods != null) { for (int i = 0; i < methods.Count; ++i) - ((Method) methods [i]).Emit (); + ((MethodOrOperator) methods [i]).Emit (); } if (fields != null) @@ -2249,8 +2182,7 @@ namespace Mono.CSharp { } if (pending != null) - if (pending.VerifyPendingMethods ()) - return; + pending.VerifyPendingMethods (); if (Report.Errors > 0) return; @@ -2297,6 +2229,7 @@ namespace Mono.CSharp { foreach (CompilerGeneratedClass c in compiler_generated) c.CloseType (); + PartialContainer = null; types = null; properties = null; delegates = null; @@ -2614,15 +2547,18 @@ namespace Mono.CSharp { if (name == MemberName.Name) { if (symbol is TypeParameter) { Report.Error (694, symbol.Location, - "Type parameter `{0}' has same name as " + - "containing type, or method", name); + "Type parameter `{0}' has same name as containing type, or method", + symbol.GetSignatureForError ()); return false; } - Report.SymbolRelatedToPreviousError (this); - Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type", - symbol.GetSignatureForError ()); - return false; + InterfaceMemberBase imb = symbol as InterfaceMemberBase; + if (imb == null || !imb.IsExplicitImpl) { + Report.SymbolRelatedToPreviousError (this); + Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type", + symbol.GetSignatureForError ()); + return false; + } } return base.AddToContainer (symbol, name); @@ -2642,7 +2578,7 @@ namespace Mono.CSharp { } } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.IsValidSecurityAttribute ()) { if (declarative_security == null) @@ -2652,11 +2588,14 @@ namespace Mono.CSharp { return; } - if (a.Type == TypeManager.struct_layout_attribute_type && a.GetLayoutKindValue () == LayoutKind.Explicit) { - PartialContainer.HasExplicitLayout = true; + if (a.Type == pa.StructLayout) { + PartialContainer.HasStructLayout = true; + + if (a.GetLayoutKindValue () == LayoutKind.Explicit) + PartialContainer.HasExplicitLayout = true; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } /// @@ -2676,27 +2615,33 @@ namespace Mono.CSharp { } Constructor c = new Constructor (this, MemberName.Name, mods, - Parameters.EmptyReadOnlyParameters, + null, ParametersCompiled.EmptyReadOnlyParameters, new GeneratedBaseInitializer (Location), Location); AddConstructor (c); - c.Block = new ToplevelBlock (null, Location); + c.Block = new ToplevelBlock (ParametersCompiled.EmptyReadOnlyParameters, Location); } public override bool Define () { - if (default_static_constructor == null && PartialContainer.HasStaticFieldInitializer) - DefineDefaultConstructor (true); + CheckProtectedModifier (); + + base.Define (); if (default_static_constructor != null) default_static_constructor.Define (); - return base.Define (); + return true; } public override void Emit () { + if (default_static_constructor == null && PartialContainer.HasStaticFieldInitializer) { + DefineDefaultConstructor (true); + default_static_constructor.Define (); + } + base.Emit (); if (declarative_security != null) { @@ -2757,27 +2702,26 @@ namespace Mono.CSharp { base.AddBasesForPart (part, bases); } - public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.attribute_usage_type) { + if (a.Type == pa.AttributeUsage) { if (!TypeManager.IsAttributeType (BaseType) && TypeBuilder.FullName != "System.Attribute") { Report.Error (641, a.Location, "Attribute `{0}' is only valid on classes derived from System.Attribute", a.GetSignatureForError ()); } } - if (a.Type == TypeManager.conditional_attribute_type && !TypeManager.IsAttributeType (BaseType)) { + if (a.Type == pa.Conditional && !TypeManager.IsAttributeType (BaseType)) { Report.Error (1689, a.Location, "Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes"); return; } - if (a.Type == TypeManager.comimport_attr_type && TypeManager.guid_attr_type != null && - !attributes.Contains (TypeManager.guid_attr_type)) { - a.Error_MissingGuidAttribute (); - return; + if (a.Type == pa.ComImport && !attributes.Contains (pa.Guid)) { + a.Error_MissingGuidAttribute (); + return; } - if (a.Type == TypeManager.extension_attribute_type) { + if (a.Type == pa.Extension) { a.Error_MisusedExtensionAttribute (); return; } @@ -2785,7 +2729,7 @@ namespace Mono.CSharp { if (AttributeTester.IsAttributeExcluded (a.Type, Location)) return; - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } public override AttributeTargets AttributeTargets { @@ -2815,11 +2759,6 @@ namespace Mono.CSharp { continue; } - if ((m.ModFlags & Modifiers.PROTECTED) != 0) { - m.CheckProtectedModifier (); - continue; - } - if (m is Indexer) { Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ()); continue; @@ -2845,19 +2784,17 @@ namespace Mono.CSharp { base.DefineContainerMembers (list); } - public override TypeBuilder DefineType () + public override bool Define () { if ((ModFlags & Modifiers.ABSTRACT) == Modifiers.ABSTRACT && (ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) != 0) { Report.Error (418, Location, "`{0}': an abstract class cannot be sealed or static", GetSignatureForError ()); - return null; } if ((ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) == (Modifiers.SEALED | Modifiers.STATIC)) { Report.Error (441, Location, "`{0}': a class cannot be both static and sealed", GetSignatureForError ()); - return null; } - return base.DefineType (); + return base.Define (); } protected override bool DoDefineMembers () @@ -2872,15 +2809,13 @@ namespace Mono.CSharp { { base.Emit (); -#if GMCS_SOURCE if ((ModFlags & Modifiers.METHOD_EXTENSION) != 0) - TypeBuilder.SetCustomAttribute (TypeManager.extension_attribute_attr); -#endif + PredefinedAttributes.Get.Extension.EmitAttribute (TypeBuilder); } - public override TypeExpr[] GetClassBases (out TypeExpr base_class) + protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { - TypeExpr[] ifaces = base.GetClassBases (out base_class); + TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class); if (base_class == null) { if (RootContext.StdLib) @@ -2896,13 +2831,19 @@ namespace Mono.CSharp { return ifaces; } + if (IsGeneric && TypeManager.IsAttributeType (base_class.Type)) { + Report.Error (698, base_class.Location, + "A generic type cannot derive from `{0}' because it is an attribute class", + base_class.GetSignatureForError ()); + } + if (base_class.IsSealed){ Report.SymbolRelatedToPreviousError (base_class.Type); if (base_class.Type.IsAbstract) { Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'", GetSignatureForError (), TypeManager.CSharpName (base_class.Type)); } else { - Report.Error (509, Location, "`{0}': cannot derive from sealed class `{1}'", + Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'", GetSignatureForError (), TypeManager.CSharpName (base_class.Type)); } return ifaces; @@ -2914,7 +2855,7 @@ namespace Mono.CSharp { return ifaces; } - if (!base_class.AsAccessible (this)) { + if (!IsAccessibleAs (base_class.Type)) { Report.SymbolRelatedToPreviousError (base_class.Type); Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'", TypeManager.CSharpName (base_class.Type), GetSignatureForError ()); @@ -2950,11 +2891,7 @@ namespace Mono.CSharp { if (OptAttributes == null) return false; - if (TypeManager.conditional_attribute_type == null) - return false; - - Attribute[] attrs = OptAttributes.SearchMulti (TypeManager.conditional_attribute_type); - + Attribute[] attrs = OptAttributes.SearchMulti (PredefinedAttributes.Get.Conditional); if (attrs == null) return false; @@ -2989,6 +2926,9 @@ namespace Mono.CSharp { } public sealed class Struct : ClassOrStruct { + + bool is_unmanaged, has_unmanaged_check_done; + // // Modifiers allowed in a struct declaration // @@ -3016,21 +2956,75 @@ namespace Mono.CSharp { this.ModFlags |= Modifiers.SEALED; } + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) + { + base.ApplyAttributeBuilder (a, cb, pa); + + // + // When struct constains fixed fixed and struct layout has explicitly + // set CharSet, its value has to be propagated to compiler generated + // fixed field types + // + if (a.Type == pa.StructLayout && Fields != null && a.HasField ("CharSet")) { + for (int i = 0; i < Fields.Count; ++i) { + FixedField ff = Fields [i] as FixedField; + if (ff != null) + ff.SetCharSet (TypeBuilder.Attributes); + } + } + } + public override AttributeTargets AttributeTargets { get { return AttributeTargets.Struct; } } - const TypeAttributes DefaultTypeAttributes = - TypeAttributes.SequentialLayout | - TypeAttributes.Sealed | - TypeAttributes.BeforeFieldInit; + public override bool IsUnmanagedType () + { + if (fields == null) + return true; + + if (requires_delayed_unmanagedtype_check) + return true; + + if (has_unmanaged_check_done) + return is_unmanaged; + has_unmanaged_check_done = true; - public override TypeExpr[] GetClassBases (out TypeExpr base_class) + foreach (FieldBase f in fields) { + if ((f.ModFlags & Modifiers.STATIC) != 0) + continue; + + // It can happen when recursive unmanaged types are defined + // struct S { S* s; } + Type mt = f.MemberType; + if (mt == null) { + has_unmanaged_check_done = false; + requires_delayed_unmanagedtype_check = true; + return true; + } + + // TODO: Remove when pointer types are under mcs control + while (mt.IsPointer) + mt = TypeManager.GetElementType (mt); + if (TypeManager.IsEqual (mt, TypeBuilder)) + continue; + + if (TypeManager.IsUnmanagedType (mt)) + continue; + + return false; + } + + is_unmanaged = true; + return true; + } + + protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { - TypeExpr[] ifaces = base.GetClassBases (out base_class); + TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class); // // If we are compiling our runtime, // and we are defining ValueType, then our @@ -3053,6 +3047,10 @@ namespace Mono.CSharp { // protected override TypeAttributes TypeAttr { get { + const TypeAttributes DefaultTypeAttributes = + TypeAttributes.SequentialLayout | + TypeAttributes.Sealed; + return base.TypeAttr | DefaultTypeAttributes; } } @@ -3099,14 +3097,14 @@ namespace Mono.CSharp { this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, name.Location); } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.comimport_attr_type && TypeManager.guid_attr_type != null && - !attributes.Contains (TypeManager.guid_attr_type)) { - a.Error_MissingGuidAttribute (); - return; + if (a.Type == pa.ComImport && !attributes.Contains (pa.Guid)) { + a.Error_MissingGuidAttribute (); + return; } - base.ApplyAttributeBuilder (a, cb); + + base.ApplyAttributeBuilder (a, cb, pa); } @@ -3116,13 +3114,13 @@ namespace Mono.CSharp { } } - const TypeAttributes DefaultTypeAttributes = - TypeAttributes.AutoLayout | - TypeAttributes.Abstract | - TypeAttributes.Interface; - protected override TypeAttributes TypeAttr { get { + const TypeAttributes DefaultTypeAttributes = + TypeAttributes.AutoLayout | + TypeAttributes.Abstract | + TypeAttributes.Interface; + return base.TypeAttr | DefaultTypeAttributes; } } @@ -3175,12 +3173,12 @@ namespace Mono.CSharp { public abstract class MethodCore : InterfaceMemberBase { - public readonly Parameters Parameters; + public readonly ParametersCompiled Parameters; protected ToplevelBlock block; public MethodCore (DeclSpace parent, GenericMethod generic, FullNamedExpression type, int mod, int allowed_mod, - MemberName name, Attributes attrs, Parameters parameters) + MemberName name, Attributes attrs, ParametersCompiled parameters) : base (parent, generic, type, mod, allowed_mod, name, attrs) { Parameters = parameters; @@ -3195,8 +3193,7 @@ namespace Mono.CSharp { } } - public Parameters ParameterInfo - { + public ParametersCompiled ParameterInfo { get { return Parameters; } @@ -3212,29 +3209,26 @@ namespace Mono.CSharp { } } + public CallingConventions CallingConventions { + get { + CallingConventions cc = Parameters.CallingConvention; + if (!IsInterface) + if ((ModFlags & Modifiers.STATIC) == 0) + cc |= CallingConventions.HasThis; + + // FIXME: How is `ExplicitThis' used in C#? + + return cc; + } + } + protected override bool CheckBase () { // Check whether arguments were correct. if (!DefineParameters (Parameters)) return false; - if ((caching_flags & Flags.MethodOverloadsExist) != 0) { - if (!Parent.MemberCache.CheckExistingMembersOverloads (this, - MemberName.IsGeneric ? MemberName.Basename : MemberName.MethodName, Parameters)) - return false; - - // TODO: Find a better way how to check reserved accessors collision - Method m = this as Method; - if (m != null) { - if (!m.CheckForDuplications ()) - return false; - } - } - - if (!base.CheckBase ()) - return false; - - return true; + return base.CheckBase (); } // @@ -3273,7 +3267,7 @@ namespace Mono.CSharp { return true; } - return false; + return base.EnableOverloadChecks (overload); } protected override bool VerifyClsCompliance () @@ -3337,6 +3331,9 @@ namespace Mono.CSharp { { if (!base.CheckBase ()) return false; + + if ((caching_flags & Flags.MethodOverloadsExist) != 0) + CheckForDuplications (); if (IsExplicitImpl) return true; @@ -3360,13 +3357,13 @@ namespace Mono.CSharp { if ((ModFlags & Modifiers.OVERRIDE) != 0) { ObsoleteAttribute oa = AttributeTester.GetMethodObsoleteAttribute (base_method); if (oa != null) { - if (OptAttributes == null || TypeManager.obsolete_attribute_type == null || !OptAttributes.Contains (TypeManager.obsolete_attribute_type)) { + if (OptAttributes == null || !OptAttributes.Contains (PredefinedAttributes.Get.Obsolete)) { Report.SymbolRelatedToPreviousError (base_method); Report.Warning (672, 1, Location, "Member `{0}' overrides obsolete member `{1}'. Add the Obsolete attribute to `{0}'", GetSignatureForError (), TypeManager.CSharpSignature (base_method)); } } else { - if (OptAttributes != null && TypeManager.obsolete_attribute_type != null && OptAttributes.Contains (TypeManager.obsolete_attribute_type)) { + if (OptAttributes != null && OptAttributes.Contains (PredefinedAttributes.Get.Obsolete)) { Report.SymbolRelatedToPreviousError (base_method); Report.Warning (809, 1, Location, "Obsolete member `{0}' overrides non-obsolete member `{1}'", GetSignatureForError (), TypeManager.CSharpSignature (base_method)); @@ -3401,7 +3398,7 @@ namespace Mono.CSharp { } if ((ModFlags & Modifiers.NEW) == 0) { - if (this is Method && conflict_symbol is MethodBase) + if (this is MethodOrOperator && conflict_symbol.MemberType == MemberTypes.Method) return true; Report.SymbolRelatedToPreviousError (conflict_symbol); @@ -3412,6 +3409,12 @@ namespace Mono.CSharp { return true; } + protected virtual bool CheckForDuplications () + { + return Parent.MemberCache.CheckExistingMembersOverloads ( + this, GetFullName (MemberName), ParametersCompiled.EmptyReadOnlyParameters); + } + // // Performs various checks on the MethodInfo `mb' regarding the modifier flags // that have been defined. @@ -3425,6 +3428,7 @@ namespace Mono.CSharp { if ((ModFlags & Modifiers.OVERRIDE) != 0){ if (!(base_method.IsAbstract || base_method.IsVirtual)){ + Report.SymbolRelatedToPreviousError (base_method); Report.Error (506, Location, "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override", GetSignatureForError (), TypeManager.CSharpSignature (base_method)); @@ -3465,12 +3469,17 @@ namespace Mono.CSharp { } if ((ModFlags & Modifiers.NEW) == 0) { - if ((ModFlags & Modifiers.OVERRIDE) == 0 && Name != "Finalize") { + if ((ModFlags & Modifiers.OVERRIDE) == 0) { ModFlags |= Modifiers.NEW; Report.SymbolRelatedToPreviousError (base_method); if (!IsInterface && (base_method.IsVirtual || base_method.IsAbstract)) { Report.Warning (114, 2, Location, "`{0}' hides inherited member `{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword", GetSignatureForError (), TypeManager.CSharpSignature (base_method)); + if (base_method.IsAbstract){ + Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'", + GetSignatureForError (), TypeManager.CSharpSignature (base_method)); + ok = false; + } } else { Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended", GetSignatureForError (), TypeManager.CSharpSignature (base_method)); @@ -3522,71 +3531,11 @@ namespace Mono.CSharp { } } - protected bool DefineParameters (Parameters parameters) - { - IResolveContext rc = GenericMethod == null ? this : (IResolveContext)ds; - - if (!parameters.Resolve (rc)) - return false; - - bool error = false; - foreach (Parameter p in parameters.FixedParameters) { - if (p.CheckAccessibility (this)) - continue; - - Report.SymbolRelatedToPreviousError (p.ParameterType); - if (this is Indexer) - Report.Error (55, Location, - "Inconsistent accessibility: parameter type `" + - TypeManager.CSharpName (p.ParameterType) + "' is less " + - "accessible than indexer `" + GetSignatureForError () + "'"); - else if (this is Operator) - Report.Error (57, Location, - "Inconsistent accessibility: parameter type `" + - TypeManager.CSharpName (p.ParameterType) + "' is less " + - "accessible than operator `" + GetSignatureForError () + "'"); - else - Report.Error (51, Location, - "Inconsistent accessibility: parameter type `{0}' is less accessible than method `{1}'", - TypeManager.CSharpName (p.ParameterType), GetSignatureForError ()); - error = true; - } - return !error; - } - - protected override bool DoDefine() - { - if (!base.DoDefine ()) - return false; - - if (IsExplicitImpl) { - TypeExpr texpr = MemberName.Left.GetTypeExpression ().ResolveAsTypeTerminal (this, false); - if (texpr == null) - return false; - - InterfaceType = texpr.Type; - - if (!InterfaceType.IsInterface) { - Report.Error (538, Location, "`{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType)); - return false; - } - - if (!Parent.PartialContainer.VerifyImplements (this)) - return false; - - } - return true; - } - - protected bool DoDefineBase () + public override bool Define () { - if (Name == null) - throw new InternalErrorException (); - if (IsInterface) { - ModFlags = Modifiers.PUBLIC | - Modifiers.ABSTRACT | - Modifiers.VIRTUAL | (ModFlags & Modifiers.UNSAFE) | (ModFlags & Modifiers.NEW); + ModFlags = Modifiers.PUBLIC | Modifiers.ABSTRACT | + Modifiers.VIRTUAL | (ModFlags & (Modifiers.UNSAFE | Modifiers.NEW)); flags = MethodAttributes.Public | MethodAttributes.Abstract | @@ -3594,8 +3543,7 @@ namespace Mono.CSharp { MethodAttributes.NewSlot | MethodAttributes.Virtual; } else { - if (!Parent.PartialContainer.MethodModifiersValid (this)) - return false; + Parent.PartialContainer.MethodModifiersValid (this); flags = Modifiers.MethodAttr (ModFlags); } @@ -3608,38 +3556,95 @@ namespace Mono.CSharp { if ((ModFlags & Modifiers.PARTIAL) != 0) { Report.Error (754, Location, "A partial method `{0}' cannot explicitly implement an interface", GetSignatureForError ()); - return false; } InterfaceType = iface_texpr.Type; if (!InterfaceType.IsInterface) { - Report.Error (538, Location, "'{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType)); - return false; + Report.SymbolRelatedToPreviousError (InterfaceType); + Report.Error (538, Location, "The type `{0}' in explicit interface declaration is not an interface", + TypeManager.CSharpName (InterfaceType)); + } else { + Parent.PartialContainer.VerifyImplements (this); } - if (!Parent.PartialContainer.VerifyImplements (this)) - return false; - Modifiers.Check (Modifiers.AllowedExplicitImplFlags, explicit_mod_flags, 0, Location); } - return true; + return base.Define (); + } + + protected bool DefineParameters (ParametersCompiled parameters) + { + IResolveContext rc = GenericMethod == null ? this : (IResolveContext)ds; + + if (!parameters.Resolve (rc)) + return false; + + bool error = false; + for (int i = 0; i < parameters.Count; ++i) { + Parameter p = parameters [i]; + + if (p.HasDefaultValue && (IsExplicitImpl || this is Operator || (this is Indexer && parameters.Count == 1))) + p.Warning_UselessOptionalParameter (); + + if (p.CheckAccessibility (this)) + continue; + + Type t = parameters.Types [i]; + Report.SymbolRelatedToPreviousError (t); + if (this is Indexer) + Report.Error (55, Location, + "Inconsistent accessibility: parameter type `{0}' is less accessible than indexer `{1}'", + TypeManager.CSharpName (t), GetSignatureForError ()); + else if (this is Operator) + Report.Error (57, Location, + "Inconsistent accessibility: parameter type `{0}' is less accessible than operator `{1}'", + TypeManager.CSharpName (t), GetSignatureForError ()); + else + Report.Error (51, Location, + "Inconsistent accessibility: parameter type `{0}' is less accessible than method `{1}'", + TypeManager.CSharpName (t), GetSignatureForError ()); + error = true; + } + return !error; } public override void Emit() { // for extern static method must be specified either DllImport attribute or MethodImplAttribute. - // We are more strict than Microsoft and report CS0626 as error + // We are more strict than csc and report this as an error because SRE does not allow emit that if ((ModFlags & Modifiers.EXTERN) != 0 && !is_external_implementation) { - Report.Error (626, Location, - "`{0}' is marked as an external but has no DllImport attribute. Consider adding a DllImport attribute to specify the external implementation", - GetSignatureForError ()); + if (this is Constructor) { + Report.Error (824, Location, + "Constructor `{0}' is marked `external' but has no external implementation specified", GetSignatureForError ()); + } else { + Report.Error (626, Location, + "`{0}' is marked as an external but has no DllImport attribute. Consider adding a DllImport attribute to specify the external implementation", + GetSignatureForError ()); + } } base.Emit (); } + public override bool EnableOverloadChecks (MemberCore overload) + { + // + // Two members can differ in their explicit interface + // type parameter only + // + InterfaceMemberBase imb = overload as InterfaceMemberBase; + if (imb != null && imb.IsExplicitImpl) { + if (IsExplicitImpl) { + caching_flags |= Flags.MethodOverloadsExist; + } + return true; + } + + return IsExplicitImpl; + } + protected void Error_CannotChangeAccessModifiers (Location loc, MemberInfo base_method, MethodAttributes ma, string suffix) { Report.SymbolRelatedToPreviousError (base_method); @@ -3675,12 +3680,23 @@ namespace Mono.CSharp { set { SetMemberName (new MemberName (MemberName.Left, value, Location)); } } + // + // Returns full metadata method name + // public string GetFullName (MemberName name) { if (!IsExplicitImpl) return name.Name; - return InterfaceType.FullName.Replace ('+', '.') + "." + name.Name; + // + // When dealing with explicit members a full interface type + // name is added to member name to avoid possible name conflicts + // + // We use CSharpName which gets us full name with benefit of + // replacing predefined names which saves some space and name + // is still unique + // + return TypeManager.CSharpName (InterfaceType) + "." + name.Name; } protected override bool VerifyClsCompliance () @@ -3720,19 +3736,19 @@ namespace Mono.CSharp { protected MethodOrOperator (DeclSpace parent, GenericMethod generic, FullNamedExpression type, int mod, int allowed_mod, MemberName name, - Attributes attrs, Parameters parameters) + Attributes attrs, ParametersCompiled parameters) : base (parent, generic, type, mod, allowed_mod, name, attrs, parameters) { } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.Target == AttributeTargets.ReturnValue) { if (return_attributes == null) return_attributes = new ReturnParameter (MethodBuilder, Location); - return_attributes.ApplyAttributeBuilder (a, cb); + return_attributes.ApplyAttributeBuilder (a, cb, pa); return; } @@ -3740,7 +3756,7 @@ namespace Mono.CSharp { is_external_implementation = true; } - if (a.Type == TypeManager.dllimport_type) { + if (a.Type == pa.DllImport) { const int extern_static = Modifiers.EXTERN | Modifiers.STATIC; if ((ModFlags & extern_static) != extern_static) { Report.Error (601, a.Location, "The DllImport attribute must be specified on a method marked `static' and `extern'"); @@ -3765,59 +3781,50 @@ namespace Mono.CSharp { } } + protected override bool CheckForDuplications () + { + string name = GetFullName (MemberName); + if (MemberName.IsGeneric) + name = MemberName.MakeName (name, MemberName.TypeArguments); + + return Parent.MemberCache.CheckExistingMembersOverloads (this, name, Parameters); + } + public virtual EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig) { return new EmitContext ( this, tc, this.ds, Location, ig, MemberType, ModFlags, false); } - protected bool DefineGenericMethod () + protected override bool ResolveMemberType () { - if (!DoDefineBase ()) - return false; - #if GMCS_SOURCE if (GenericMethod != null) { MethodBuilder = Parent.TypeBuilder.DefineMethod (GetFullName (MemberName), flags); - if (!GenericMethod.Define (MethodBuilder)) + if (!GenericMethod.Define (this)) return false; } #endif - return true; - } - - public bool ResolveMembers () - { - if (!DefineGenericMethod ()) - return false; - - return true; + return base.ResolveMemberType (); } public override bool Define () { - if (!DoDefine ()) - return false; - - if (!CheckAbstractAndExtern (block != null)) + if (!base.Define ()) return false; - if ((ModFlags & Modifiers.PARTIAL) != 0) { - for (int i = 0; i < Parameters.Count; ++i ) { - if (Parameters.ParameterModifier (i) == Parameter.Modifier.OUT) { - Report.Error (752, Location, "`{0}': A partial method parameters cannot use `out' modifier", - GetSignatureForError ()); - return false; - } - } - } - if (!CheckBase ()) return false; - if (block != null && block.IsIterator && !(Parent is IteratorStorey)) + if (block != null && block.IsIterator && !(Parent is IteratorStorey)) { + // + // Current method is turned into automatically generated + // wrapper which creates an instance of iterator + // Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags); + ModFlags |= Modifiers.DEBUGGER_HIDDEN; + } if (IsPartialDefinition) { caching_flags &= ~Flags.Excluded_Undetected; @@ -3840,31 +3847,57 @@ namespace Mono.CSharp { MethodBuilder = MethodData.MethodBuilder; -#if GMCS_SOURCE - if (MethodBuilder.IsGenericMethod) + if (TypeManager.IsGenericMethod (MethodBuilder)) Parent.MemberCache.AddGenericMember (MethodBuilder, this); -#endif Parent.MemberCache.AddMember (MethodBuilder, this); + return true; + } + + protected override void DoMemberTypeIndependentChecks () + { + base.DoMemberTypeIndependentChecks (); + + CheckAbstractAndExtern (block != null); + + if ((ModFlags & Modifiers.PARTIAL) != 0) { + for (int i = 0; i < Parameters.Count; ++i) { + IParameterData p = Parameters.FixedParameters [i]; + if (p.ModFlags == Parameter.Modifier.OUT) { + Report.Error (752, Location, "`{0}': A partial method parameters cannot use `out' modifier", + GetSignatureForError ()); + } + + if (p.HasDefaultValue && IsPartialImplementation) + ((Parameter) p).Warning_UselessOptionalParameter (); + } + } + } + + protected override void DoMemberTypeDependentChecks () + { + base.DoMemberTypeDependentChecks (); + if (!TypeManager.IsGenericParameter (MemberType)) { if (MemberType.IsAbstract && MemberType.IsSealed) { Report.Error (722, Location, Error722, TypeManager.CSharpName (MemberType)); - return false; } } - - return true; } public override void Emit () { -#if GMCS_SOURCE if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated) - MethodBuilder.SetCustomAttribute (TypeManager.GetCompilerGeneratedAttribute (Location)); + PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (MethodBuilder); if ((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0) - MethodBuilder.SetCustomAttribute (TypeManager.GetDebuggerHiddenAttribute (Location)); -#endif + PredefinedAttributes.Get.DebuggerHidden.EmitAttribute (MethodBuilder); + + if (TypeManager.IsDynamicType (ReturnType)) { + return_attributes = new ReturnParameter (MethodBuilder, Location); + return_attributes.EmitPredefined (PredefinedAttributes.Get.Dynamic, Location); + } + if (OptAttributes != null) OptAttributes.Emit (); @@ -3874,7 +3907,13 @@ namespace Mono.CSharp { } } + if (MethodData != null) + MethodData.Emit (Parent); + base.Emit (); + + Block = null; + MethodData = null; } protected void Error_ConditionalAttributeIsNotValid () @@ -3904,19 +3943,6 @@ namespace Mono.CSharp { #region IMethodData Members - public CallingConventions CallingConventions { - get { - CallingConventions cc = Parameters.CallingConvention; - if (!IsInterface) - if ((ModFlags & Modifiers.STATIC) == 0) - cc |= CallingConventions.HasThis; - - // FIXME: How is `ExplicitThis' used in C#? - - return cc; - } - } - public Type ReturnType { get { return MemberType; @@ -3929,21 +3955,6 @@ namespace Mono.CSharp { } } - protected override bool CheckBase () - { - if (!base.CheckBase ()) - return false; - - // TODO: Destructor should derive from MethodCore - if (base_method != null && (ModFlags & Modifiers.OVERRIDE) != 0 && Name == "Finalize" && - base_method.DeclaringType == TypeManager.object_type && !(this is Destructor)) { - Report.Error (249, Location, "Do not override object.Finalize. Instead, provide a destructor"); - return false; - } - - return true; - } - /// /// Returns true if method has conditional attribute and the conditions is not defined (method is excluded). /// @@ -3957,10 +3968,7 @@ namespace Mono.CSharp { if (OptAttributes == null) return false; - if (TypeManager.conditional_attribute_type == null) - return false; - - Attribute[] attrs = OptAttributes.SearchMulti (TypeManager.conditional_attribute_type); + Attribute[] attrs = OptAttributes.SearchMulti (PredefinedAttributes.Get.Conditional); if (attrs == null) return false; @@ -4086,9 +4094,11 @@ namespace Mono.CSharp { const int AllowedInterfaceModifiers = Modifiers.NEW | Modifiers.UNSAFE; + Method partialMethodImplementation; + public Method (DeclSpace parent, GenericMethod generic, FullNamedExpression return_type, int mod, - MemberName name, Parameters parameters, Attributes attrs) + MemberName name, ParametersCompiled parameters, Attributes attrs) : base (parent, generic, return_type, mod, parent.PartialContainer.Kind == Kind.Interface ? AllowedInterfaceModifiers : AllowedModifiers, name, attrs, parameters) @@ -4096,7 +4106,7 @@ namespace Mono.CSharp { } protected Method (DeclSpace parent, FullNamedExpression return_type, int mod, int amod, - MemberName name, Parameters parameters, Attributes attrs) + MemberName name, ParametersCompiled parameters, Attributes attrs) : base (parent, null, return_type, mod, amod, name, attrs, parameters) { } @@ -4106,11 +4116,11 @@ namespace Mono.CSharp { return base.GetSignatureForError () + Parameters.GetSignatureForError (); } - void Error_DuplicateEntryPoint (MethodInfo b, Location location) + static void Error_DuplicateEntryPoint (Method b) { - Report.Error (17, location, + Report.Error (17, b.Location, "Program `{0}' has more than one entry point defined: `{1}'", - CodeGen.FileName, TypeManager.CSharpSignature(b)); + CodeGen.FileName, b.GetSignatureForError ()); } bool IsEntryPoint () @@ -4125,15 +4135,15 @@ namespace Mono.CSharp { if (Parameters.Count > 1) return false; - Type t = Parameters.ParameterType (0); + Type t = Parameters.Types [0]; return t.IsArray && t.GetArrayRank () == 1 && TypeManager.GetElementType (t) == TypeManager.string_type && (Parameters[0].ModFlags & ~Parameter.Modifier.PARAMS) == Parameter.Modifier.NONE; } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.conditional_attribute_type) { + if (a.Type == pa.Conditional) { if (IsExplicitImpl) { Error_ConditionalAttributeIsNotValid (); return; @@ -4162,23 +4172,26 @@ namespace Mono.CSharp { } for (int i = 0; i < Parameters.Count; ++i) { - if ((Parameters.ParameterModifier (i) & Parameter.Modifier.OUTMASK) != 0) { + if (Parameters.FixedParameters [i].ModFlags == Parameter.Modifier.OUT) { Report.Error (685, Location, "Conditional method `{0}' cannot have an out parameter", GetSignatureForError ()); return; } } } - if (a.Type == TypeManager.extension_attribute_type) { + if (a.Type == pa.Extension) { a.Error_MisusedExtensionAttribute (); return; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } - public bool CheckForDuplications () + protected override bool CheckForDuplications () { + if (!base.CheckForDuplications ()) + return false; + ArrayList ar = Parent.PartialContainer.Properties; if (ar != null) { for (int i = 0; i < ar.Count; ++i) { @@ -4200,28 +4213,43 @@ namespace Mono.CSharp { return true; } + protected override bool CheckBase () + { + if (!base.CheckBase ()) + return false; + + if (base_method != null && (ModFlags & Modifiers.OVERRIDE) != 0 && Name == Destructor.MetadataName) { + Report.Error (249, Location, "Do not override `{0}'. Use destructor syntax instead", + TypeManager.CSharpSignature (base_method)); + } + + return true; + } + // // Creates the type // public override bool Define () { + if (type_name == TypeManager.system_void_expr && Parameters.IsEmpty && Name == Destructor.MetadataName) { + Report.Warning (465, 1, Location, "Introducing `Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?"); + } + if (!base.Define ()) return false; - if (RootContext.StdLib && (ReturnType == TypeManager.arg_iterator_type || ReturnType == TypeManager.typed_reference_type)) { + if (partialMethodImplementation != null && IsPartialDefinition) + MethodBuilder = partialMethodImplementation.MethodBuilder; + + if (RootContext.StdLib && TypeManager.IsSpecialType (ReturnType)) { Error1599 (Location, ReturnType); return false; } - if (ReturnType == TypeManager.void_type && ParameterTypes.Length == 0 && - Name == "Finalize" && !(this is Destructor)) { - Report.Warning (465, 1, Location, "Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?"); - } - if (base_method != null && (ModFlags & Modifiers.NEW) == 0) { if (Parameters.Count == 1 && ParameterTypes [0] == TypeManager.object_type && Name == "Equals") Parent.PartialContainer.Mark_HasEquals (); - else if (Parameters.Empty && Name == "GetHashCode") + else if (Parameters.IsEmpty && Name == "GetHashCode") Parent.PartialContainer.Mark_HasGetHashCode (); } @@ -4229,25 +4257,20 @@ namespace Mono.CSharp { return true; if (Parameters.HasExtensionMethodType) { - if (Parent.IsStaticClass && !Parent.IsGeneric) { + if (Parent.PartialContainer.IsStaticClass && !Parent.IsGeneric) { if (!Parent.IsTopLevel) Report.Error (1109, Location, "`{0}': Extension methods cannot be defined in a nested class", GetSignatureForError ()); - if (TypeManager.extension_attribute_type == null) { + PredefinedAttribute pa = PredefinedAttributes.Get.Extension; + if (!pa.IsDefined) { Report.Error (1110, Location, "`{0}': Extension methods cannot be declared without a reference to System.Core.dll assembly. Add the assembly reference or remove `this' modifer from the first parameter", GetSignatureForError ()); - } else if (TypeManager.extension_attribute_attr == null) { - ConstructorInfo ci = TypeManager.GetPredefinedConstructor ( - TypeManager.extension_attribute_type, Location, System.Type.EmptyTypes); - - if (ci != null) - TypeManager.extension_attribute_attr = new CustomAttributeBuilder (ci, new object [0]); } ModFlags |= Modifiers.METHOD_EXTENSION; - Parent.ModFlags |= Modifiers.METHOD_EXTENSION; + Parent.PartialContainer.ModFlags |= Modifiers.METHOD_EXTENSION; CodeGen.Assembly.HasExtensionMethods = true; } else { Report.Error (1106, Location, "`{0}': Extension methods must be defined in a non-generic static class", @@ -4269,15 +4292,12 @@ namespace Mono.CSharp { Report.Warning (402, 4, Location, "`{0}': an entry point cannot be generic or in a generic type", GetSignatureForError ()); } else { - IMethodData md = TypeManager.GetMethod (MethodBuilder); - md.SetMemberIsUsed (); - - RootContext.EntryPoint = MethodBuilder; - RootContext.EntryPointLocation = Location; + SetMemberIsUsed (); + RootContext.EntryPoint = this; } } else { - Error_DuplicateEntryPoint (RootContext.EntryPoint, RootContext.EntryPointLocation); - Error_DuplicateEntryPoint (MethodBuilder, Location); + Error_DuplicateEntryPoint (RootContext.EntryPoint); + Error_DuplicateEntryPoint (this); } } else { Report.Warning (28, 4, Location, "`{0}' has the wrong signature to be an entry point", @@ -4297,28 +4317,21 @@ namespace Mono.CSharp { Report.Debug (64, "METHOD EMIT", this, MethodBuilder, Location, Block, MethodData); if (IsPartialDefinition) { // - // Do attribute checks only when partial implementation does not exist + // Use partial method implementation builder for partial method declaration attributes // - if (MethodBuilder == null) - base.Emit (); - - return; - } - - if ((ModFlags & Modifiers.PARTIAL) != 0 && (caching_flags & Flags.PartialDefinitionExists) == 0) + if (partialMethodImplementation != null) { + MethodBuilder = partialMethodImplementation.MethodBuilder; + return; + } + } else if ((ModFlags & Modifiers.PARTIAL) != 0 && (caching_flags & Flags.PartialDefinitionExists) == 0) { Report.Error (759, Location, "A partial method `{0}' implementation is missing a partial method declaration", GetSignatureForError ()); + } - MethodData.Emit (Parent); base.Emit (); -#if GMCS_SOURCE if ((ModFlags & Modifiers.METHOD_EXTENSION) != 0) - MethodBuilder.SetCustomAttribute (TypeManager.extension_attribute_attr); -#endif - - Block = null; - MethodData = null; + PredefinedAttributes.Get.Extension.EmitAttribute (MethodBuilder); } catch { Console.WriteLine ("Internal compiler error at {0}: exception caught while emitting {1}", Location, MethodBuilder); @@ -4346,7 +4359,7 @@ namespace Mono.CSharp { protected override MethodInfo FindOutBaseMethod (ref Type base_ret_type) { MethodInfo mi = (MethodInfo) Parent.PartialContainer.BaseCache.FindMemberToOverride ( - Parent.TypeBuilder, Name, ParameterTypes, GenericMethod, false); + Parent.TypeBuilder, Name, Parameters, GenericMethod, false); if (mi == null) return null; @@ -4361,7 +4374,12 @@ namespace Mono.CSharp { public void SetPartialDefinition (Method methodDefinition) { caching_flags |= Flags.PartialDefinitionExists; - methodDefinition.MethodBuilder = MethodBuilder; + methodDefinition.partialMethodImplementation = this; + + for (int i = 0; i < methodDefinition.Parameters.Count; ++i ) { + Parameters [i].DefaultValue = methodDefinition.Parameters [i].DefaultValue; + } + if (methodDefinition.attributes == null) return; @@ -4377,7 +4395,7 @@ namespace Mono.CSharp { if (!base.VerifyClsCompliance ()) return false; - if (ParameterInfo.Count > 0) { + if (!Parameters.IsEmpty) { ArrayList al = (ArrayList)Parent.PartialContainer.MemberCache.Members [Name]; if (al.Count > 1) MemberCache.VerifyClsParameterConflict (al, this, MethodBuilder); @@ -4389,16 +4407,16 @@ namespace Mono.CSharp { public abstract class ConstructorInitializer : ExpressionStatement { - ArrayList argument_list; + Arguments argument_list; MethodGroupExpr base_constructor_group; - - public ConstructorInitializer (ArrayList argument_list, Location loc) + + public ConstructorInitializer (Arguments argument_list, Location loc) { this.argument_list = argument_list; this.loc = loc; } - public ArrayList Arguments { + public Arguments Arguments { get { return argument_list; } @@ -4409,24 +4427,26 @@ namespace Mono.CSharp { throw new NotSupportedException ("ET"); } - public bool Resolve (ConstructorBuilder caller_builder, EmitContext ec) + public ExpressionStatement Resolve (ConstructorBuilder caller_builder, EmitContext ec) { - if (argument_list != null){ - foreach (Argument a in argument_list){ - if (!a.Resolve (ec, loc)) - return false; + if (argument_list != null) { + bool dynamic; + argument_list.Resolve (ec, out dynamic); + if (dynamic) { + SimpleName ctor = new SimpleName (ConstructorBuilder.ConstructorName, loc); + return new DynamicInvocation (ctor, argument_list, loc).Resolve (ec) as ExpressionStatement; } } if (this is ConstructorBaseInitializer) { if (ec.ContainerType.BaseType == null) - return true; + return this; type = ec.ContainerType.BaseType; - if (ec.ContainerType.IsValueType) { + if (TypeManager.IsStruct (ec.ContainerType)) { Report.Error (522, loc, "`{0}': Struct constructors cannot call base constructors", TypeManager.CSharpSignature (caller_builder)); - return false; + return this; } } else { // @@ -4435,8 +4455,8 @@ namespace Mono.CSharp { // // struct D { public D (int a) : this () {} // - if (ec.ContainerType.IsValueType && argument_list == null) - return true; + if (TypeManager.IsStruct (ec.ContainerType) && argument_list == null) + return this; type = ec.ContainerType; } @@ -4447,13 +4467,13 @@ namespace Mono.CSharp { loc) as MethodGroupExpr; if (base_constructor_group == null) - return false; + return this; base_constructor_group = base_constructor_group.OverloadResolve ( ec, ref argument_list, false, loc); if (base_constructor_group == null) - return false; + return this; ConstructorInfo base_ctor = (ConstructorInfo)base_constructor_group; @@ -4461,7 +4481,7 @@ namespace Mono.CSharp { Report.Error (516, loc, "Constructor `{0}' cannot call itself", TypeManager.CSharpSignature (caller_builder)); } - return true; + return this; } public override Expression DoResolve (EmitContext ec) @@ -4489,7 +4509,7 @@ namespace Mono.CSharp { } public class ConstructorBaseInitializer : ConstructorInitializer { - public ConstructorBaseInitializer (ArrayList argument_list, Location l) : + public ConstructorBaseInitializer (Arguments argument_list, Location l) : base (argument_list, l) { } @@ -4503,7 +4523,7 @@ namespace Mono.CSharp { } public class ConstructorThisInitializer : ConstructorInitializer { - public ConstructorThisInitializer (ArrayList argument_list, Location l) : + public ConstructorThisInitializer (Arguments argument_list, Location l) : base (argument_list, l) { } @@ -4533,10 +4553,10 @@ namespace Mono.CSharp { // The spec claims that static is not permitted, but // my very own code has static constructors. // - public Constructor (DeclSpace parent, string name, int mod, Parameters args, + public Constructor (DeclSpace parent, string name, int mod, Attributes attrs, ParametersCompiled args, ConstructorInitializer init, Location loc) : base (parent, null, null, mod, AllowedModifiers, - new MemberName (name, loc), null, args) + new MemberName (name, loc), attrs, args) { Initializer = init; } @@ -4555,14 +4575,14 @@ namespace Mono.CSharp { public bool IsDefault () { if ((ModFlags & Modifiers.STATIC) != 0) - return Parameters.Empty; + return Parameters.IsEmpty; - return Parameters.Empty && + return Parameters.IsEmpty && (Initializer is ConstructorBaseInitializer) && (Initializer.Arguments == null); } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.IsValidSecurityAttribute ()) { if (declarative_security == null) { @@ -4582,7 +4602,7 @@ namespace Mono.CSharp { protected override bool CheckBase () { if ((ModFlags & Modifiers.STATIC) != 0) { - if (!Parameters.Empty) { + if (!Parameters.IsEmpty) { Report.Error (132, Location, "`{0}': The static constructor must be parameterless", GetSignatureForError ()); return false; @@ -4597,11 +4617,11 @@ namespace Mono.CSharp { return false; if ((caching_flags & Flags.MethodOverloadsExist) != 0) - Parent.MemberCache.CheckExistingMembersOverloads (this, ConstructorBuilder.ConstructorName, + Parent.MemberCache.CheckExistingMembersOverloads (this, ConstructorInfo.ConstructorName, Parameters); if (Parent.PartialContainer.Kind == Kind.Struct) { - if (ParameterTypes.Length == 0) { + if (Parameters.Count == 0) { Report.Error (568, Location, "Structs cannot contain explicit parameterless constructors"); return false; @@ -4651,13 +4671,12 @@ namespace Mono.CSharp { ConstructorBuilder = Parent.TypeBuilder.DefineConstructor ( ca, CallingConventions, - ParameterTypes); + Parameters.GetEmitTypes ()); if (Parent.PartialContainer.IsComImport) { if (!IsDefault ()) { Report.Error (669, Location, "`{0}': A class with the ComImport attribute cannot have a user-defined constructor", Parent.GetSignatureForError ()); - return false; } ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall); } @@ -4680,7 +4699,7 @@ namespace Mono.CSharp { public override void Emit () { if ((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0) - ConstructorBuilder.SetCustomAttribute (TypeManager.GetDebuggerHiddenAttribute (Location)); + PredefinedAttributes.Get.DebuggerHidden.EmitAttribute (ConstructorBuilder); if (OptAttributes != null) OptAttributes.Emit (); @@ -4706,7 +4725,7 @@ namespace Mono.CSharp { ((ModFlags & Modifiers.STATIC) == 0) && (Initializer == null)) block.AddThisVariable (Parent, Location); - if (!block.ResolveMeta (ec, ParameterInfo)) + if (!block.ResolveMeta (ec, Parameters)) block = null; if (block != null && (ModFlags & Modifiers.STATIC) == 0){ @@ -4718,9 +4737,9 @@ namespace Mono.CSharp { // if (Initializer != null) { ec.IsStatic = true; - Initializer.Resolve (ConstructorBuilder, ec); + ExpressionStatement expr = Initializer.Resolve (ConstructorBuilder, ec); ec.IsStatic = false; - block.AddScopeStatement (new StatementExpression (Initializer)); + block.AddScopeStatement (new StatementExpression (expr)); } } } @@ -4735,7 +4754,7 @@ namespace Mono.CSharp { bool unreachable = false; if (block != null) { - if (!ec.ResolveTopBlock (null, block, ParameterInfo, this, out unreachable)) + if (!ec.ResolveTopBlock (null, block, Parameters, this, out unreachable)) return; ec.EmitMeta (block); @@ -4743,9 +4762,6 @@ namespace Mono.CSharp { if (Report.Errors > 0) return; - if (emit_field_initializers) - Parent.PartialContainer.EmitFieldInitializers (ec); - ec.EmitResolvedTopBlock (block, unreachable); } @@ -4784,13 +4800,13 @@ namespace Mono.CSharp { return false; } - if (ParameterInfo.Count > 0) { - ArrayList al = (ArrayList)Parent.MemberCache.Members [".ctor"]; + if (!Parameters.IsEmpty) { + ArrayList al = (ArrayList)Parent.MemberCache.Members [ConstructorInfo.ConstructorName]; if (al.Count > 2) MemberCache.VerifyClsParameterConflict (al, this, ConstructorBuilder); if (TypeManager.IsSubclassOf (Parent.TypeBuilder, TypeManager.attribute_type)) { - foreach (Type param in ParameterTypes) { + foreach (Type param in Parameters.Types) { if (param.IsArray) { return true; } @@ -4803,20 +4819,6 @@ namespace Mono.CSharp { #region IMethodData Members - public System.Reflection.CallingConventions CallingConventions { - get { - CallingConventions cc = Parameters.CallingConvention; - - if (Parent.PartialContainer.Kind == Kind.Class) - if ((ModFlags & Modifiers.STATIC) == 0) - cc |= CallingConventions.HasThis; - - // FIXME: How is `ExplicitThis' used in C#? - - return cc; - } - } - public MemberName MethodName { get { return MemberName; @@ -4864,7 +4866,7 @@ namespace Mono.CSharp { MemberName MethodName { get; } Type ReturnType { get; } GenericMethod GenericMethod { get; } - Parameters ParameterInfo { get; } + ParametersCompiled ParameterInfo { get; } Attributes OptAttributes { get; } ToplevelBlock Block { get; set; } @@ -4882,9 +4884,7 @@ namespace Mono.CSharp { // Encapsulates most of the Method's state // public class MethodData { -#if GMCS_SOURCE static FieldInfo methodbuilder_attrs_field; -#endif public readonly IMethodData method; public readonly GenericMethod GenericMethod; @@ -5066,7 +5066,7 @@ namespace Mono.CSharp { flags |= MethodAttributes.Final; } - DefineMethodBuilder (container, method_full_name, method.ParameterInfo.Types); + DefineMethodBuilder (container, method_full_name, method.ParameterInfo); if (builder == null) return false; @@ -5076,15 +5076,8 @@ namespace Mono.CSharp { else declaring_type = container.TypeBuilder; - if (implementing != null){ - // - // clear the pending implemntation flag - // - pending.ImplementMethod (name, member.InterfaceType, this, member.IsExplicitImpl); - - if (member.IsExplicitImpl) - container.TypeBuilder.DefineMethodOverride ( - builder, implementing); + if (implementing != null && member.IsExplicitImpl) { + container.TypeBuilder.DefineMethodOverride (builder, implementing); } TypeManager.AddMethod (builder, method); @@ -5108,12 +5101,13 @@ namespace Mono.CSharp { /// /// Create the MethodBuilder for the method /// - void DefineMethodBuilder (TypeContainer container, string method_name, Type[] ParameterTypes) + void DefineMethodBuilder (TypeContainer container, string method_name, ParametersCompiled param) { if (builder == null) { builder = container.TypeBuilder.DefineMethod ( method_name, flags, method.CallingConventions, - method.ReturnType, ParameterTypes); + TypeManager.TypeToReflectionType (method.ReturnType), + param.GetEmitTypes ()); return; } @@ -5122,9 +5116,9 @@ namespace Mono.CSharp { // Generic method has been already defined to resolve method parameters // correctly when they use type parameters // - builder.SetParameters (ParameterTypes); + builder.SetParameters (param.GetEmitTypes ()); builder.SetReturnType (method.ReturnType); - +#endif if (builder.Attributes != flags) { try { if (methodbuilder_attrs_field == null) @@ -5134,9 +5128,6 @@ namespace Mono.CSharp { Report.RuntimeMissingSupport (method.Location, "Generic method MethodAttributes"); } } -#else - throw new InternalErrorException (); -#endif } // @@ -5157,89 +5148,89 @@ namespace Mono.CSharp { if (GenericMethod != null) GenericMethod.EmitAttributes (); - SourceMethod source = SourceMethod.Create (parent, MethodBuilder, method.Block); - - // - // Handle destructors specially // - // FIXME: This code generates buggy code + // clear the pending implementation flag // - if (member is Destructor) - EmitDestructor (ec, block); - else - ec.EmitTopBlock (method, block); - - if (source != null) { - method.EmitExtraSymbolInfo (source); - source.CloseMethod (); - } - } + if (implementing != null) + parent.PartialContainer.PendingImplementations.ImplementMethod (method.MethodName.Basename, + member.InterfaceType, this, member.IsExplicitImpl); - void EmitDestructor (EmitContext ec, ToplevelBlock block) - { - ILGenerator ig = ec.ig; - - Label finish = ig.DefineLabel (); + SourceMethod source = SourceMethod.Create (parent, MethodBuilder, method.Block); - block.SetDestructor (); - - ig.BeginExceptionBlock (); - ec.ReturnLabel = finish; - ec.HasReturnLabel = true; ec.EmitTopBlock (method, block); - - // ig.MarkLabel (finish); - ig.BeginFinallyBlock (); - - if (ec.ContainerType.BaseType != null) { - Expression member_lookup = Expression.MemberLookup ( - ec.ContainerType.BaseType, null, ec.ContainerType.BaseType, - "Finalize", MemberTypes.Method, Expression.AllBindingFlags, method.Location); - if (member_lookup != null){ - MethodGroupExpr base_destructor = ((MethodGroupExpr) member_lookup); - - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Call, (MethodInfo) base_destructor.Methods [0]); - } + if (source != null) { + method.EmitExtraSymbolInfo (source); + source.CloseMethod (); } - - ig.EndExceptionBlock (); - //ig.MarkLabel (ec.ReturnLabel); - ig.Emit (OpCodes.Ret); } } - // TODO: Should derive from MethodCore - public class Destructor : Method + public class Destructor : MethodOrOperator { const int AllowedModifiers = Modifiers.UNSAFE | Modifiers.EXTERN; - static string[] attribute_targets = new string [] { "method" }; + static readonly string[] attribute_targets = new string [] { "method" }; + + public static readonly string MetadataName = "Finalize"; - public Destructor (DeclSpace parent, FullNamedExpression return_type, int mod, - string name, Parameters parameters, Attributes attrs, - Location l) - : base (parent, return_type, mod, AllowedModifiers, new MemberName (name, l), - parameters, attrs) + public Destructor (DeclSpace parent, int mod, ParametersCompiled parameters, Attributes attrs, Location l) + : base (parent, null, TypeManager.system_void_expr, mod, AllowedModifiers, + new MemberName (MetadataName, l), attrs, parameters) { ModFlags &= ~Modifiers.PRIVATE; - if (!RootContext.StdLib && parent.Name == "System.Object") - ModFlags |= Modifiers.PROTECTED | Modifiers.VIRTUAL; - else - ModFlags |= Modifiers.PROTECTED | Modifiers.OVERRIDE; + ModFlags |= Modifiers.PROTECTED; } - public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.conditional_attribute_type) { + if (a.Type == pa.Conditional) { Error_ConditionalAttributeIsNotValid (); return; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); + } + + protected override bool CheckBase () + { + flags |= MethodAttributes.Virtual; + + if (!base.CheckBase ()) + return false; + + if (Parent.PartialContainer.BaseCache == null) + return true; + + Type base_type = Parent.PartialContainer.BaseCache.Container.Type; + if (base_type != null && Block != null) { + MethodGroupExpr method_expr = Expression.MethodLookup (Parent.TypeBuilder, base_type, MetadataName, Location); + if (method_expr == null) + throw new NotImplementedException (); + + method_expr.IsBase = true; + method_expr.InstanceExpression = new CompilerGeneratedThis (Parent.TypeBuilder, Location); + + ToplevelBlock new_block = new ToplevelBlock (Block.StartLocation); + new_block.EndLocation = Block.EndLocation; + + Block finaly_block = new ExplicitBlock (new_block, Location, Location); + Block try_block = new Block (new_block, block); + + // + // 0-size arguments to avoid CS0250 error + // TODO: Should use AddScopeStatement or something else which emits correct + // debugger scope + // + finaly_block.AddStatement (new StatementExpression (new Invocation (method_expr, new Arguments (0)))); + new_block.AddStatement (new TryFinally (try_block, finaly_block, Location)); + + block = new_block; + } + + return true; } public override string GetSignatureForError () @@ -5247,6 +5238,11 @@ namespace Mono.CSharp { return Parent.GetSignatureForError () + ".~" + Parent.MemberName.Name + "()"; } + protected override MethodInfo FindOutBaseMethod (ref Type base_ret_type) + { + return null; + } + public override string[] ValidAttributeTargets { get { return attribute_targets; @@ -5254,32 +5250,14 @@ namespace Mono.CSharp { } } - abstract public class MemberBase : MemberCore { + public abstract class MemberBase : MemberCore + { protected FullNamedExpression type_name; + protected Type member_type; + public readonly DeclSpace ds; public readonly GenericMethod GenericMethod; - // - // The type of this property / indexer / event - // - protected Type member_type; - public Type MemberType { - get { - // TODO: Who wrote this, ResolveAsTypeTerminal can have side effects - if (member_type == null && type_name != null) { - IResolveContext rc = GenericMethod == null ? this : (IResolveContext)ds; - type_name = type_name.ResolveAsTypeTerminal (rc, false); - if (type_name != null) { - member_type = type_name.Type; - } - } - return member_type; - } - } - - // - // The constructor is only exposed to our children - // protected MemberBase (DeclSpace parent, GenericMethod generic, FullNamedExpression type, int mod, int allowed_mod, int def_mod, MemberName name, Attributes attrs) @@ -5293,25 +5271,40 @@ namespace Mono.CSharp { GenericMethod.ModFlags = ModFlags; } - protected virtual bool CheckBase () + // + // Main member define entry + // + public override bool Define () { - CheckProtectedModifier (); + DoMemberTypeIndependentChecks (); + + // + // Returns false only when type resolution failed + // + if (!ResolveMemberType ()) + return false; + DoMemberTypeDependentChecks (); return true; } - protected virtual bool DoDefine () + // + // Any type_name independent checks + // + protected virtual void DoMemberTypeIndependentChecks () { - if (MemberType == null) - return false; - - if ((Parent.ModFlags & Modifiers.SEALED) != 0 && - (ModFlags & (Modifiers.VIRTUAL|Modifiers.ABSTRACT)) != 0) { - Report.Error (549, Location, "New virtual member `{0}' is declared in a sealed class `{1}'", - GetSignatureForError (), Parent.GetSignatureForError ()); - return false; + if ((Parent.ModFlags & Modifiers.SEALED) != 0 && + (ModFlags & (Modifiers.VIRTUAL | Modifiers.ABSTRACT)) != 0) { + Report.Error (549, Location, "New virtual member `{0}' is declared in a sealed class `{1}'", + GetSignatureForError (), Parent.GetSignatureForError ()); } - + } + + // + // Any type_name dependent checks + // + protected virtual void DoMemberTypeDependentChecks () + { // verify accessibility if (!IsAccessibleAs (MemberType)) { Report.SymbolRelatedToPreviousError (MemberType); @@ -5342,20 +5335,50 @@ namespace Mono.CSharp { TypeManager.CSharpName (MemberType) + "' is less " + "accessible than field `" + GetSignatureForError () + "'"); } - return false; } - return true; + Variance variance = this is Event ? Variance.Contravariant : Variance.Covariant; + TypeManager.CheckTypeVariance (MemberType, variance, this); } protected bool IsTypePermitted () { - if (MemberType == TypeManager.arg_iterator_type || MemberType == TypeManager.typed_reference_type) { + if (TypeManager.IsSpecialType (MemberType)) { Report.Error (610, Location, "Field or property cannot be of type `{0}'", TypeManager.CSharpName (MemberType)); return false; } return true; } + + protected virtual bool CheckBase () + { + CheckProtectedModifier (); + + return true; + } + + public Type MemberType { + get { return member_type; } + } + + protected virtual bool ResolveMemberType () + { + if (member_type != null) + throw new InternalErrorException ("Multi-resolve"); + + IResolveContext rc = GenericMethod == null ? this : (IResolveContext) ds; + TypeExpr te = type_name.ResolveAsTypeTerminal (rc, false); + if (te == null) + return false; + + // + // Replace original type name, error reporting can use fully resolved name + // + type_name = te; + + member_type = te.Type; + return true; + } } // @@ -5388,9 +5411,9 @@ namespace Mono.CSharp { } } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.field_offset_attribute_type) { + if (a.Type == pa.FieldOffset) { status |= Status.HAS_OFFSET; if (!Parent.PartialContainer.HasExplicitLayout) { @@ -5405,14 +5428,14 @@ namespace Mono.CSharp { } #if NET_2_0 - if (a.Type == TypeManager.fixed_buffer_attr_type) { + if (a.Type == pa.FixedBuffer) { Report.Error (1716, Location, "Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead"); return; } #endif #if !NET_2_0 - if (a.Type == TypeManager.marshal_as_attr_type) { + if (a.Type == pa.MarshalAs) { UnmanagedMarshal marshal = a.GetMarshal (this); if (marshal != null) { FieldBuilder.SetMarshal (marshal); @@ -5441,7 +5464,7 @@ namespace Mono.CSharp { return true; } - if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE)) == 0) { + if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.BACKING_FIELD)) == 0) { Report.SymbolRelatedToPreviousError (conflict_symbol); Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol)); @@ -5450,35 +5473,19 @@ namespace Mono.CSharp { return true; } - public override bool Define() + protected override void DoMemberTypeDependentChecks () { - if (MemberType == null || member_type == null) - return false; + base.DoMemberTypeDependentChecks (); if (TypeManager.IsGenericParameter (MemberType)) - return true; - - if (MemberType == TypeManager.void_type) { - // TODO: wrong location - Expression.Error_VoidInvalidInTheContext (Location); - return false; - } + return; if (MemberType.IsSealed && MemberType.IsAbstract) { Error_VariableOfStaticClass (Location, GetSignatureForError (), MemberType); - return false; } - if (!CheckBase ()) - return false; - - if (!DoDefine ()) - return false; - - if (!IsTypePermitted ()) - return false; - - return true; + CheckBase (); + IsTypePermitted (); } // @@ -5490,17 +5497,18 @@ namespace Mono.CSharp { public override void Emit () { -#if GMCS_SOURCE + if (TypeManager.IsDynamicType (member_type)) + PredefinedAttributes.Get.Dynamic.EmitAttribute (FieldBuilder); + if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated) - FieldBuilder.SetCustomAttribute (TypeManager.GetCompilerGeneratedAttribute (Location)); -#endif + PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (FieldBuilder); if (OptAttributes != null) { OptAttributes.Emit (); } - if (((status & Status.HAS_OFFSET) == 0) && (ModFlags & Modifiers.STATIC) == 0 && Parent.PartialContainer.HasExplicitLayout) { - Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute.", GetSignatureForError ()); + if (((status & Status.HAS_OFFSET) == 0) && (ModFlags & (Modifiers.STATIC | Modifiers.BACKING_FIELD)) == 0 && Parent.PartialContainer.HasExplicitLayout) { + Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute", GetSignatureForError ()); } base.Emit (); @@ -5612,7 +5620,7 @@ namespace Mono.CSharp { Expression size_expr, Attributes attrs, Location loc): base (parent, type, mod, AllowedModifiers, new MemberName (name, loc), attrs) { - if (RootContext.Version == LanguageVersion.ISO_1) + if (RootContext.Version < LanguageVersion.ISO_2) Report.FeatureIsNotAvailable (loc, "fixed size buffers"); this.size_expr = size_expr; @@ -5620,9 +5628,6 @@ namespace Mono.CSharp { public override bool Define() { - if (!Parent.IsInUnsafeScope) - Expression.UnsafeError (Location); - if (!base.Define ()) return false; @@ -5633,7 +5638,7 @@ namespace Mono.CSharp { // Create nested fixed buffer container string name = String.Format ("<{0}>__FixedBuffer{1}", Name, GlobalCounter++); - fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name, + fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name, Parent.Module.DefaultCharSetType | TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, TypeManager.value_type); element = fixed_buffer_type.DefineField (FixedElementName, MemberType, FieldAttributes.Public); @@ -5646,19 +5651,27 @@ namespace Mono.CSharp { return true; } - public override void Emit() + protected override void DoMemberTypeIndependentChecks () { + base.DoMemberTypeIndependentChecks (); + + if (!Parent.IsInUnsafeScope) + Expression.UnsafeError (Location); + if (Parent.PartialContainer.Kind != Kind.Struct) { Report.Error (1642, Location, "`{0}': Fixed size buffer fields may only be members of structs", GetSignatureForError ()); } + } + public override void Emit() + { EmitContext ec = new EmitContext (this, Parent, Location, null, TypeManager.void_type, ModFlags); Constant c = size_expr.ResolveAsConstant (ec, this); if (c == null) return; - - IntConstant buffer_size_const = c.ImplicitConversionRequired (TypeManager.int32_type, Location) as IntConstant; + + IntConstant buffer_size_const = c.ImplicitConversionRequired (ec, TypeManager.int32_type, Location) as IntConstant; if (buffer_size_const == null) return; @@ -5679,32 +5692,28 @@ namespace Mono.CSharp { buffer_size *= type_size; EmitFieldSize (buffer_size); + + PredefinedAttributes.Get.UnsafeValueType.EmitAttribute (fixed_buffer_type); + base.Emit (); } void EmitFieldSize (int buffer_size) { - if (TypeManager.struct_layout_attribute_type == null) { - TypeManager.struct_layout_attribute_type = TypeManager.CoreLookupType ( - "System.Runtime.InteropServices", "StructLayoutAttribute", Kind.Class, true); + CustomAttributeBuilder cab; + PredefinedAttribute pa; - if (TypeManager.struct_layout_attribute_type == null) + pa = PredefinedAttributes.Get.StructLayout; + if (pa.Constructor == null && + !pa.ResolveConstructor (Location, TypeManager.short_type)) return; - } + // TODO: It's not cleared if (fi == null) - fi = new FieldInfo [] { TypeManager.struct_layout_attribute_type.GetField ("Size") }; - - object [] fi_val = new object [] { buffer_size }; + fi = new FieldInfo[] { pa.Type.GetField ("Size") }; - if (TypeManager.struct_layout_attribute_ctor == null) { - TypeManager.struct_layout_attribute_ctor = TypeManager.GetPredefinedConstructor ( - TypeManager.struct_layout_attribute_type, Location, TypeManager.short_type); - if (TypeManager.struct_layout_attribute_ctor == null) - return; - } - - CustomAttributeBuilder cab = new CustomAttributeBuilder (TypeManager.struct_layout_attribute_ctor, + object[] fi_val = new object[] { buffer_size }; + cab = new CustomAttributeBuilder (pa.Constructor, ctor_args, fi, fi_val); fixed_buffer_type.SetCustomAttribute (cab); @@ -5712,31 +5721,41 @@ namespace Mono.CSharp { // Don't emit FixedBufferAttribute attribute for private types // if ((ModFlags & Modifiers.PRIVATE) != 0) - return; + return; - if (TypeManager.fixed_buffer_attr_ctor == null) { - if (TypeManager.fixed_buffer_attr_type == null) { - TypeManager.fixed_buffer_attr_type = TypeManager.CoreLookupType ( - "System.Runtime.CompilerServices", "FixedBufferAttribute", Kind.Class, true); + pa = PredefinedAttributes.Get.FixedBuffer; + if (pa.Constructor == null && + !pa.ResolveConstructor (Location, TypeManager.type_type, TypeManager.int32_type)) + return; - if (TypeManager.fixed_buffer_attr_type == null) - return; - } + cab = new CustomAttributeBuilder (pa.Constructor, new object[] { MemberType, buffer_size }); + FieldBuilder.SetCustomAttribute (cab); + } - TypeManager.fixed_buffer_attr_ctor = TypeManager.GetPredefinedConstructor (TypeManager.fixed_buffer_attr_type, - Location, TypeManager.type_type, TypeManager.int32_type); - - if (TypeManager.fixed_buffer_attr_ctor == null) - return; + protected override bool IsFieldClsCompliant { + get { + return false; } + } - cab = new CustomAttributeBuilder (TypeManager.fixed_buffer_attr_ctor, new object [] { MemberType, buffer_size }); - FieldBuilder.SetCustomAttribute (cab); + public void SetCharSet (TypeAttributes ta) + { + TypeAttributes cta = fixed_buffer_type.Attributes; + if ((cta & TypeAttributes.UnicodeClass) != (ta & TypeAttributes.UnicodeClass)) + SetTypeBuilderCharSet ((cta & ~TypeAttributes.AutoClass) | TypeAttributes.UnicodeClass); + else if ((cta & TypeAttributes.AutoClass) != (ta & TypeAttributes.AutoClass)) + SetTypeBuilderCharSet ((cta & ~TypeAttributes.UnicodeClass) | TypeAttributes.AutoClass); + else if (cta == 0 && ta != 0) + SetTypeBuilderCharSet (cta & ~(TypeAttributes.UnicodeClass | TypeAttributes.AutoClass)); } - protected override bool IsFieldClsCompliant { - get { - return false; + void SetTypeBuilderCharSet (TypeAttributes ta) + { + MethodInfo mi = typeof (TypeBuilder).GetMethod ("SetCharSet", BindingFlags.Instance | BindingFlags.NonPublic); + if (mi == null) { + Report.RuntimeMissingSupport (Location, "TypeBuilder::SetCharSet"); + } else { + mi.Invoke (fixed_buffer_type, new object [] { ta }); } } @@ -5775,10 +5794,9 @@ namespace Mono.CSharp { Modifiers.UNSAFE | Modifiers.READONLY; - public Field (DeclSpace parent, FullNamedExpression type, int mod, string name, - Attributes attrs, Location loc) - : base (parent, type, mod, AllowedModifiers, new MemberName (name, loc), - attrs) + public Field (DeclSpace parent, FullNamedExpression type, int mod, MemberName name, + Attributes attrs) + : base (parent, type, mod, AllowedModifiers, name, attrs) { } @@ -5787,37 +5805,51 @@ namespace Mono.CSharp { if (TypeManager.IsReferenceType (MemberType)) return true; - if (MemberType.IsEnum) - return true; - if (MemberType == TypeManager.bool_type || MemberType == TypeManager.char_type || MemberType == TypeManager.sbyte_type || MemberType == TypeManager.byte_type || MemberType == TypeManager.short_type || MemberType == TypeManager.ushort_type || MemberType == TypeManager.int32_type || MemberType == TypeManager.uint32_type || - MemberType == TypeManager.float_type) + MemberType == TypeManager.float_type || + MemberType == TypeManager.intptr_type || MemberType == TypeManager.uintptr_type) + return true; + + if (TypeManager.IsEnumType (MemberType)) return true; return false; } - public override bool Define () + bool CheckStructLayout (Type type, bool isStatic) { - if (!base.Define ()) - return false; + if (TypeManager.IsBuiltinType (type)) + return true; - if ((ModFlags & Modifiers.VOLATILE) != 0){ - if (!CanBeVolatile ()) { - Report.Error (677, Location, "`{0}': A volatile field cannot be of the type `{1}'", - GetSignatureForError (), TypeManager.CSharpName (MemberType)); - } + if (isStatic) { + if (!TypeManager.IsValueType (type) || TypeManager.IsEqual (type, Parent.TypeBuilder)) + return true; + } - if ((ModFlags & Modifiers.READONLY) != 0){ - Report.Error (678, Location, "`{0}': A field cannot be both volatile and readonly", - GetSignatureForError ()); + if (!TypeManager.IsEqual (TypeManager.DropGenericTypeArguments (type), Parent.TypeBuilder)) { + if (!TypeManager.IsGenericType (type)) + return true; + + foreach (Type t in TypeManager.GetTypeArguments (type)) { + if (!CheckStructLayout (t, false)) + return false; } + return true; } + + Report.Error (523, Location, + "Struct member `{0}' of type `{1}' causes a cycle in the struct layout", + GetSignatureForError (), TypeManager.CSharpName (MemberType)); + return false; + } - FieldAttributes fa = Modifiers.FieldAttr (ModFlags); + public override bool Define () + { + if (!base.Define ()) + return false; try { #if GMCS_SOURCE @@ -5837,37 +5869,44 @@ namespace Mono.CSharp { FieldBuilder = Parent.TypeBuilder.DefineField ( Name, MemberType, Modifiers.FieldAttr (ModFlags)); #endif - Parent.MemberCache.AddMember (FieldBuilder, this); + // Don't cache inaccessible fields + if ((ModFlags & Modifiers.BACKING_FIELD) == 0) { + Parent.MemberCache.AddMember (FieldBuilder, this); + } + TypeManager.RegisterFieldBase (FieldBuilder, this); } catch (ArgumentException) { - Report.Warning (-24, 1, Location, "The Microsoft runtime is unable to use [void|void*] as a field type, try using the Mono runtime."); + Report.RuntimeMissingSupport (Location, "`void' or `void*' field type"); return false; } - if (initializer != null) + if (initializer != null) { ((TypeContainer) Parent).RegisterFieldForInitialization (this, - new FieldInitializer (FieldBuilder, initializer)); - - if (Parent.PartialContainer.Kind == Kind.Struct && (fa & FieldAttributes.Static) == 0 && - MemberType == Parent.TypeBuilder && !TypeManager.IsBuiltinType (MemberType) && initializer == null) { - Report.Error (523, Location, "Struct member `{0}' causes a cycle in the structure layout", - GetSignatureForError ()); - return false; + new FieldInitializer (FieldBuilder, initializer, this)); + } else { + if (Parent.PartialContainer.Kind == Kind.Struct) + CheckStructLayout (member_type, (ModFlags & Modifiers.STATIC) != 0); } return true; } - public override string GetSignatureForError () + protected override void DoMemberTypeDependentChecks () { - string s = base.GetSignatureForError (); - if ((ModFlags & Modifiers.BACKING_FIELD) == 0) - return s; + base.DoMemberTypeDependentChecks (); - // Undecorate name mangling - int l = s.LastIndexOf ('>'); - return s.Substring (0, l).Remove (s.LastIndexOf ('<'), 1); + if ((ModFlags & Modifiers.VOLATILE) != 0) { + if (!CanBeVolatile ()) { + Report.Error (677, Location, "`{0}': A volatile field cannot be of the type `{1}'", + GetSignatureForError (), TypeManager.CSharpName (MemberType)); + } + + if ((ModFlags & Modifiers.READONLY) != 0) { + Report.Error (678, Location, "`{0}': A field cannot be both volatile and readonly", + GetSignatureForError ()); + } + } } protected override bool VerifyClsCompliance () @@ -5900,12 +5939,14 @@ namespace Mono.CSharp { public Attributes Attributes; public Location Location; public int ModFlags; + public ParametersCompiled Parameters; - public Accessor (ToplevelBlock b, int mod, Attributes attrs, Location loc) + public Accessor (ToplevelBlock b, int mod, Attributes attrs, ParametersCompiled p, Location loc) { Block = b; Attributes = attrs; Location = loc; + Parameters = p; ModFlags = Modifiers.Check (AllowedModifiers, mod, 0, loc); } } @@ -5917,7 +5958,7 @@ namespace Mono.CSharp { protected ToplevelBlock block; protected ListDictionary declarative_security; - // The accessor are created event if they are not wanted. + // The accessor are created even if they are not wanted. // But we need them because their names are reserved. // Field says whether accessor will be emited or not public readonly bool IsDummy; @@ -5993,16 +6034,15 @@ namespace Mono.CSharp { } } - public abstract Parameters ParameterInfo { get ; } + public abstract ParametersCompiled ParameterInfo { get ; } public abstract Type ReturnType { get; } public abstract EmitContext CreateEmitContext (DeclSpace ds, ILGenerator ig); #endregion - public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.cls_compliant_attribute_type || a.Type == TypeManager.obsolete_attribute_type || - a.Type == TypeManager.conditional_attribute_type) { + if (a.Type == pa.CLSCompliant || a.Type == pa.Obsolete || a.Type == pa.Conditional) { Report.Error (1667, a.Location, "Attribute `{0}' is not valid on property or event accessors. It is valid on `{1}' declarations only", TypeManager.CSharpName (a.Type), a.GetValidTargets ()); @@ -6025,14 +6065,14 @@ namespace Mono.CSharp { if (return_attributes == null) return_attributes = new ReturnParameter (method_data.MethodBuilder, Location); - return_attributes.ApplyAttributeBuilder (a, cb); + return_attributes.ApplyAttributeBuilder (a, cb, pa); return; } - ApplyToExtraTarget (a, cb); + ApplyToExtraTarget (a, cb, pa); } - virtual protected void ApplyToExtraTarget (Attribute a, CustomAttributeBuilder cb) + protected virtual void ApplyToExtraTarget (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { throw new NotSupportedException ("You forgot to define special attribute target handling"); } @@ -6043,16 +6083,20 @@ namespace Mono.CSharp { throw new NotSupportedException (); } - public void Emit (DeclSpace parent) + public virtual void Emit (DeclSpace parent) { - EmitMethod (parent); + method_data.Emit (parent); -#if GMCS_SOURCE if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated) - method_data.MethodBuilder.SetCustomAttribute (TypeManager.GetCompilerGeneratedAttribute (Location)); + PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (method_data.MethodBuilder); if (((ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)) - method_data.MethodBuilder.SetCustomAttribute (TypeManager.GetDebuggerHiddenAttribute (Location)); -#endif + PredefinedAttributes.Get.DebuggerHidden.EmitAttribute (method_data.MethodBuilder); + + if (TypeManager.IsDynamicType (ReturnType)) { + return_attributes = new ReturnParameter (method_data.MethodBuilder, Location); + return_attributes.EmitPredefined (PredefinedAttributes.Get.Dynamic, Location); + } + if (OptAttributes != null) OptAttributes.Emit (); @@ -6065,11 +6109,6 @@ namespace Mono.CSharp { block = null; } - protected virtual void EmitMethod (DeclSpace parent) - { - method_data.Emit (parent); - } - public override bool EnableOverloadChecks (MemberCore overload) { // This can only happen with indexers and it will @@ -6152,14 +6191,11 @@ namespace Mono.CSharp { public override MethodBuilder Define (DeclSpace parent) { - if (!CheckForDuplications ()) - return null; + base.Define (parent); if (IsDummy) return null; - base.Define (parent); - method_data = new MethodData (method, ModFlags, flags, this); if (!method_data.Define (parent, method.GetFullName (MemberName))) @@ -6174,9 +6210,9 @@ namespace Mono.CSharp { } } - public override Parameters ParameterInfo { + public override ParametersCompiled ParameterInfo { get { - return Parameters.EmptyReadOnlyParameters; + return ParametersCompiled.EmptyReadOnlyParameters; } } @@ -6191,55 +6227,49 @@ namespace Mono.CSharp { static string[] attribute_targets = new string [] { "method", "param", "return" }; ImplicitParameter param_attr; - protected Parameters parameters; + protected ParametersCompiled parameters; - public SetMethod (PropertyBase method): + public SetMethod (PropertyBase method) : base (method, "set_") { + parameters = new ParametersCompiled ( + new Parameter (method.type_name, "value", Parameter.Modifier.NONE, null, Location)); } public SetMethod (PropertyBase method, Accessor accessor): base (method, accessor, "set_") { + this.parameters = accessor.Parameters; } - protected override void ApplyToExtraTarget(Attribute a, CustomAttributeBuilder cb) + protected override void ApplyToExtraTarget (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.Target == AttributeTargets.Parameter) { if (param_attr == null) param_attr = new ImplicitParameter (method_data.MethodBuilder); - param_attr.ApplyAttributeBuilder (a, cb); + param_attr.ApplyAttributeBuilder (a, cb, pa); return; } - base.ApplyAttributeBuilder (a, cb); - } - - public override Parameters ParameterInfo { - get { - if (parameters == null) - DefineParameters (); - return parameters; - } + base.ApplyAttributeBuilder (a, cb, pa); } - protected virtual void DefineParameters () - { - parameters = Parameters.CreateFullyResolved ( - new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location)); + public override ParametersCompiled ParameterInfo { + get { + return parameters; + } } public override MethodBuilder Define (DeclSpace parent) { - if (!CheckForDuplications ()) - return null; + parameters.Resolve (this); + base.Define (parent); + if (IsDummy) return null; - base.Define (parent); - method_data = new MethodData (method, ModFlags, flags, this); if (!method_data.Define (parent, method.GetFullName (MemberName))) @@ -6272,6 +6302,7 @@ namespace Mono.CSharp { : base (method, prefix) { this.method = method; + this.ModFlags = method.ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE); } public PropertyMethod (PropertyBase method, Accessor accessor, @@ -6279,20 +6310,20 @@ namespace Mono.CSharp { : base (method, accessor, prefix) { this.method = method; - this.ModFlags = accessor.ModFlags; + this.ModFlags = accessor.ModFlags | (method.ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE)); if (accessor.ModFlags != 0 && RootContext.Version == LanguageVersion.ISO_1) { Report.FeatureIsNotAvailable (Location, "access modifiers on properties"); } } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.IsInternalMethodImplAttribute) { method.is_external_implementation = true; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } public override AttributeTargets AttributeTargets { @@ -6308,6 +6339,21 @@ namespace Mono.CSharp { public virtual MethodBuilder Define (DeclSpace parent) { + CheckForDuplications (); + + if (IsDummy) { + if (method.InterfaceType != null && parent.PartialContainer.PendingImplementations != null) { + MethodInfo mi = parent.PartialContainer.PendingImplementations.IsInterfaceMethod ( + MethodName.Name, method.InterfaceType, new MethodData (method, ModFlags, flags, this)); + if (mi != null) { + Report.SymbolRelatedToPreviousError (mi); + Report.Error (551, Location, "Explicit interface implementation `{0}' is missing accessor `{1}'", + method.GetSignatureForError (), TypeManager.CSharpSignature (mi, true)); + } + } + return null; + } + TypeContainer container = parent.PartialContainer; // @@ -6340,13 +6386,18 @@ namespace Mono.CSharp { return null; } - public bool HasCustomAccessModifier - { + public bool HasCustomAccessModifier { get { return (ModFlags & Modifiers.PROPERTY_CUSTOM) != 0; } } + public PropertyBase Property { + get { + return method; + } + } + public override EmitContext CreateEmitContext (DeclSpace ds, ILGenerator ig) { return new EmitContext (this, @@ -6389,7 +6440,7 @@ namespace Mono.CSharp { } } - protected bool CheckForDuplications () + protected bool CheckForDuplications () { if ((caching_flags & Flags.MethodOverloadsExist) == 0) return true; @@ -6412,7 +6463,7 @@ namespace Mono.CSharp { this.define_set_first = define_set_first; } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.HasSecurityAttribute) { a.Error_InvalidSecurityParent (); @@ -6428,21 +6479,24 @@ namespace Mono.CSharp { } } - public override bool Define () + protected override void DoMemberTypeDependentChecks () { - if (!DoDefine ()) - return false; + base.DoMemberTypeDependentChecks (); - if (!IsTypePermitted ()) - return false; + IsTypePermitted (); +#if MS_COMPATIBLE + if (MemberType.IsGenericParameter) + return; +#endif - return true; + if ((MemberType.Attributes & Class.StaticClassAttribute) == Class.StaticClassAttribute) { + Report.Error (722, Location, Error722, TypeManager.CSharpName (MemberType)); + } } - protected override bool DoDefine () + protected override void DoMemberTypeIndependentChecks () { - if (!base.DoDefine ()) - return false; + base.DoMemberTypeIndependentChecks (); // // Accessors modifiers check @@ -6451,28 +6505,15 @@ namespace Mono.CSharp { (Set.ModFlags & Modifiers.Accessibility) != 0) { Report.Error (274, Location, "`{0}': Cannot specify accessibility modifiers for both accessors of the property or indexer", GetSignatureForError ()); - return false; } - if ((Get.IsDummy || Set.IsDummy) - && (Get.ModFlags != 0 || Set.ModFlags != 0) && (ModFlags & Modifiers.OVERRIDE) == 0) { + if ((ModFlags & Modifiers.OVERRIDE) == 0 && + (Get.IsDummy && (Set.ModFlags & Modifiers.Accessibility) != 0) || + (Set.IsDummy && (Get.ModFlags & Modifiers.Accessibility) != 0)) { Report.Error (276, Location, "`{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor", GetSignatureForError ()); - return false; - } - -#if MS_COMPATIBLE - if (MemberType.IsGenericParameter) - return true; -#endif - - if ((MemberType.Attributes & Class.StaticClassAttribute) == Class.StaticClassAttribute) { - Report.Error (722, Location, Error722, TypeManager.CSharpName (MemberType)); - return false; } - - return true; } bool DefineGet () @@ -6564,8 +6605,13 @@ namespace Mono.CSharp { // case, we do not actually emit the ".property", so there is nowhere to // put the attribute // - if (PropertyBuilder != null && OptAttributes != null) - OptAttributes.Emit (); + if (PropertyBuilder != null) { + if (OptAttributes != null) + OptAttributes.Emit (); + + if (TypeManager.IsDynamicType (member_type)) + PredefinedAttributes.Get.Dynamic.EmitAttribute (PropertyBuilder); + } if (!Get.IsDummy) Get.Emit (Parent); @@ -6616,7 +6662,26 @@ namespace Mono.CSharp { } } - public class Property : PropertyBase { + public class Property : PropertyBase + { + public sealed class BackingField : Field + { + readonly Property property; + + public BackingField (Property p) + : base (p.Parent, p.type_name, + Modifiers.BACKING_FIELD | Modifiers.COMPILER_GENERATED | Modifiers.PRIVATE | (p.ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE)), + new MemberName ("<" + p.GetFullName (p.MemberName) + ">k__BackingField", p.Location), null) + { + this.property = p; + } + + public override string GetSignatureForError () + { + return property.GetSignatureForError (); + } + } + const int AllowedModifiers = Modifiers.NEW | Modifiers.PUBLIC | @@ -6634,29 +6699,6 @@ namespace Mono.CSharp { const int AllowedInterfaceModifiers = Modifiers.NEW; - void CreateAutomaticProperty (Block block, Accessor get_block, Accessor set_block) - { - // Make the field - Field field = new Field ( - Parent, type_name, - Modifiers.BACKING_FIELD | Modifiers.PRIVATE | (ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE)), - "<" + Name + ">k__BackingField", null, Location); - ((TypeContainer)Parent).PartialContainer.AddField (field); - - // Make get block - get_block.Block = new ToplevelBlock (block, null, Location); - Return r = new Return (new SimpleName(field.Name, Location), Location); - get_block.Block.AddStatement (r); - get_block.ModFlags |= Modifiers.COMPILER_GENERATED; - - // Make set block - Parameters parameters = new Parameters (new Parameter (type_name, "value", Parameter.Modifier.NONE, null, Location)); - set_block.Block = new ToplevelBlock (block, parameters, Location); - Assign a = new SimpleAssign (new SimpleName (field.Name, Location), new SimpleName ("value", Location)); - set_block.Block.AddStatement (new StatementExpression(a)); - set_block.ModFlags |= Modifiers.COMPILER_GENERATED; - } - public Property (DeclSpace parent, FullNamedExpression type, int mod, MemberName name, Attributes attrs, Accessor get_block, Accessor set_block, bool define_set_first) @@ -6672,15 +6714,6 @@ namespace Mono.CSharp { parent.PartialContainer.Kind == Kind.Interface ? AllowedInterfaceModifiers : AllowedModifiers, name, attrs, define_set_first) { - if (!IsInterface && (mod & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0 && - get_block != null && get_block.Block == null && - set_block != null && set_block.Block == null) { - if (RootContext.Version <= LanguageVersion.ISO_2) - Report.FeatureIsNotAvailable (Location, "automatically implemented properties"); - - CreateAutomaticProperty (current_block, get_block, set_block); - } - if (get_block == null) Get = new GetMethod (this); else @@ -6690,18 +6723,52 @@ namespace Mono.CSharp { Set = new SetMethod (this); else Set = new SetMethod (this, set_block); + + if (!IsInterface && (mod & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0 && + get_block != null && get_block.Block == null && + set_block != null && set_block.Block == null) { + if (RootContext.Version <= LanguageVersion.ISO_2) + Report.FeatureIsNotAvailable (Location, "automatically implemented properties"); + + Get.ModFlags |= Modifiers.COMPILER_GENERATED; + Set.ModFlags |= Modifiers.COMPILER_GENERATED; + } } - public override bool Define () + void CreateAutomaticProperty () { - if (!DoDefineBase ()) - return false; + // Create backing field + Field field = new BackingField (this); + if (!field.Define ()) + return; + + Parent.PartialContainer.AddField (field); + + FieldExpr fe = new FieldExpr (field.FieldBuilder, Location); + if ((field.ModFlags & Modifiers.STATIC) == 0) + fe.InstanceExpression = new CompilerGeneratedThis (fe.Type, Location); + + // Create get block + Get.Block = new ToplevelBlock (ParametersCompiled.EmptyReadOnlyParameters, Location); + Return r = new Return (fe, Location); + Get.Block.AddStatement (r); + + // Create set block + Set.Block = new ToplevelBlock (Set.ParameterInfo, Location); + Assign a = new SimpleAssign (fe, new SimpleName ("value", Location)); + Set.Block.AddStatement (new StatementExpression (a)); + } + public override bool Define () + { if (!base.Define ()) return false; flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName; + if ((Get.ModFlags & Modifiers.COMPILER_GENERATED) != 0) + CreateAutomaticProperty (); + if (!DefineAccessors ()) return false; @@ -6728,10 +6795,21 @@ namespace Mono.CSharp { return true; } + public override void Emit () + { + if (((Set.ModFlags | Get.ModFlags) & (Modifiers.STATIC | Modifiers.COMPILER_GENERATED)) == Modifiers.COMPILER_GENERATED && Parent.PartialContainer.HasExplicitLayout) { + Report.Error (842, Location, + "Automatically implemented property `{0}' cannot be used inside a type with an explicit StructLayout attribute", + GetSignatureForError ()); + } + + base.Emit (); + } + protected override PropertyInfo ResolveBaseProperty () { return Parent.PartialContainer.BaseCache.FindMemberToOverride ( - Parent.TypeBuilder, Name, Parameters.EmptyReadOnlyParameters.Types, null, true) as PropertyInfo; + Parent.TypeBuilder, Name, ParametersCompiled.EmptyReadOnlyParameters, null, true) as PropertyInfo; } } @@ -6907,29 +6985,17 @@ namespace Mono.CSharp { sealed class AddDelegateMethod: AEventPropertyAccessor { public AddDelegateMethod (Event method, Accessor accessor): - base (method, accessor, "add_") + base (method, accessor, AddPrefix) { } - - protected override MethodInfo DelegateMethodInfo { - get { - return TypeManager.delegate_combine_delegate_delegate; - } - } } sealed class RemoveDelegateMethod: AEventPropertyAccessor { public RemoveDelegateMethod (Event method, Accessor accessor): - base (method, accessor, "remove_") + base (method, accessor, RemovePrefix) { } - - protected override MethodInfo DelegateMethodInfo { - get { - return TypeManager.delegate_remove_delegate_delegate; - } - } } @@ -6971,65 +7037,54 @@ namespace Mono.CSharp { { } - protected override void EmitMethod(DeclSpace parent) + public override void Emit (DeclSpace parent) { - if ((method.ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0) - return; - - MethodBuilder mb = method_data.MethodBuilder; - ILGenerator ig = mb.GetILGenerator (); + if ((method.ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0) { + if (parent is Class) { + MethodBuilder mb = method_data.MethodBuilder; + mb.SetImplementationFlags (mb.GetMethodImplementationFlags () | MethodImplAttributes.Synchronized); + } - // TODO: because we cannot use generics yet - FieldInfo field_info = ((EventField)method).FieldBuilder; + // TODO: because we cannot use generics yet + FieldInfo field_info = ((EventField) method).BackingField.FieldBuilder; + FieldExpr f_expr = new FieldExpr (field_info, Location); + if ((method.ModFlags & Modifiers.STATIC) == 0) + f_expr.InstanceExpression = new CompilerGeneratedThis (field_info.FieldType, Location); - if (parent is Class) { - mb.SetImplementationFlags (mb.GetMethodImplementationFlags () | MethodImplAttributes.Synchronized); + block = new ToplevelBlock (ParameterInfo, Location); + block.AddStatement (new StatementExpression ( + new CompoundAssign (Operation, + f_expr, + block.GetParameterReference (ParameterInfo[0].Name, Location)))); } - - if ((method.ModFlags & Modifiers.STATIC) != 0) { - ig.Emit (OpCodes.Ldsfld, field_info); - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Call, DelegateMethodInfo); - ig.Emit (OpCodes.Castclass, method.MemberType); - ig.Emit (OpCodes.Stsfld, field_info); - } else { - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldfld, field_info); - ig.Emit (OpCodes.Ldarg_1); - ig.Emit (OpCodes.Call, DelegateMethodInfo); - ig.Emit (OpCodes.Castclass, method.MemberType); - ig.Emit (OpCodes.Stfld, field_info); - } - ig.Emit (OpCodes.Ret); + + base.Emit (parent); } + + protected abstract Binary.Operator Operation { get; } } sealed class AddDelegateMethod: EventFieldAccessor { public AddDelegateMethod (Event method): - base (method, "add_") + base (method, AddPrefix) { } - protected override MethodInfo DelegateMethodInfo { - get { - return TypeManager.delegate_combine_delegate_delegate; - } + protected override Binary.Operator Operation { + get { return Binary.Operator.Addition; } } } sealed class RemoveDelegateMethod: EventFieldAccessor { public RemoveDelegateMethod (Event method): - base (method, "remove_") + base (method, RemovePrefix) { } - protected override MethodInfo DelegateMethodInfo { - get { - return TypeManager.delegate_remove_delegate_delegate; - } + protected override Binary.Operator Operation { + get { return Binary.Operator.Subtraction; } } } @@ -7037,7 +7092,7 @@ namespace Mono.CSharp { static readonly string[] attribute_targets = new string [] { "event", "field", "method" }; static readonly string[] attribute_targets_interface = new string[] { "event", "method" }; - public FieldBuilder FieldBuilder; + public Field BackingField; public Expression Initializer; public EventField (DeclSpace parent, FullNamedExpression type, int mod_flags, MemberName name, Attributes attrs) @@ -7047,22 +7102,22 @@ namespace Mono.CSharp { Remove = new RemoveDelegateMethod (this); } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.Target == AttributeTargets.Field) { - FieldBuilder.SetCustomAttribute (cb); + BackingField.ApplyAttributeBuilder (a, cb, pa); return; } if (a.Target == AttributeTargets.Method) { int errors = Report.Errors; - Add.ApplyAttributeBuilder (a, cb); + Add.ApplyAttributeBuilder (a, cb, pa); if (errors == Report.Errors) - Remove.ApplyAttributeBuilder (a, cb); + Remove.ApplyAttributeBuilder (a, cb, pa); return; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } public override bool Define() @@ -7070,41 +7125,50 @@ namespace Mono.CSharp { if (!base.Define ()) return false; - if (IsInterface) + if (Initializer != null && (ModFlags & Modifiers.ABSTRACT) != 0) { + Report.Error (74, Location, "`{0}': abstract event cannot have an initializer", + GetSignatureForError ()); + } + + if (!HasBackingField) { + SetMemberIsUsed (); return true; + } // FIXME: We are unable to detect whether generic event is used because // we are using FieldExpr instead of EventExpr for event access in that // case. When this issue will be fixed this hack can be removed. if (TypeManager.IsGenericType (MemberType)) - SetMemberIsUsed(); + SetMemberIsUsed (); if (Add.IsInterfaceImplementation) SetMemberIsUsed (); - FieldBuilder = Parent.TypeBuilder.DefineField ( - Name, MemberType, - FieldAttributes.Private | ((ModFlags & Modifiers.STATIC) != 0 ? FieldAttributes.Static : 0)); TypeManager.RegisterEventField (EventBuilder, this); - if (Initializer != null) { - if (((ModFlags & Modifiers.ABSTRACT) != 0)) { - Report.Error (74, Location, "`{0}': abstract event cannot have an initializer", - GetSignatureForError ()); - return false; - } + BackingField = new Field (Parent, + new TypeExpression (MemberType, Location), + Modifiers.BACKING_FIELD | Modifiers.COMPILER_GENERATED | Modifiers.PRIVATE | (ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE)), + MemberName, null); - ((TypeContainer) Parent).RegisterFieldForInitialization (this, - new FieldInitializer (FieldBuilder, Initializer)); - } + Parent.PartialContainer.AddField (BackingField); + BackingField.Initializer = Initializer; + BackingField.ModFlags &= ~Modifiers.COMPILER_GENERATED; - return true; + // Call define because we passed fields definition + return BackingField.Define (); + } + + bool HasBackingField { + get { + return !IsInterface && (ModFlags & Modifiers.ABSTRACT) == 0; + } } public override string[] ValidAttributeTargets { get { - return IsInterface ? attribute_targets_interface : attribute_targets; + return HasBackingField ? attribute_targets : attribute_targets_interface; } } } @@ -7117,6 +7181,9 @@ namespace Mono.CSharp { static readonly string[] attribute_targets = new string [] { "method", "param", "return" }; + public const string AddPrefix = "add_"; + public const string RemovePrefix = "remove_"; + protected AEventAccessor (Event method, string prefix) : base (method, prefix) { @@ -7135,26 +7202,26 @@ namespace Mono.CSharp { get { return method_data.implementing != null; } } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.IsInternalMethodImplAttribute) { method.is_external_implementation = true; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } - protected override void ApplyToExtraTarget(Attribute a, CustomAttributeBuilder cb) + protected override void ApplyToExtraTarget (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if (a.Target == AttributeTargets.Parameter) { if (param_attr == null) param_attr = new ImplicitParameter (method_data.MethodBuilder); - param_attr.ApplyAttributeBuilder (a, cb); + param_attr.ApplyAttributeBuilder (a, cb, pa); return; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } public override AttributeTargets AttributeTargets { @@ -7181,8 +7248,6 @@ namespace Mono.CSharp { return mb; } - protected abstract MethodInfo DelegateMethodInfo { get; } - public override Type ReturnType { get { return TypeManager.void_type; @@ -7207,7 +7272,7 @@ namespace Mono.CSharp { } } - public override Parameters ParameterInfo { + public override ParametersCompiled ParameterInfo { get { return method.parameters; } @@ -7236,7 +7301,7 @@ namespace Mono.CSharp { public MyEventBuilder EventBuilder; public MethodBuilder AddBuilder, RemoveBuilder; - Parameters parameters; + ParametersCompiled parameters; protected Event (DeclSpace parent, FullNamedExpression type, int mod_flags, MemberName name, Attributes attrs) : base (parent, null, type, mod_flags, @@ -7245,7 +7310,7 @@ namespace Mono.CSharp { { } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { if ((a.HasSecurityAttribute)) { a.Error_InvalidSecurityParent (); @@ -7268,19 +7333,15 @@ namespace Mono.CSharp { public override bool Define () { - if (!DoDefineBase ()) - return false; - - if (!DoDefine ()) + if (!base.Define ()) return false; if (!TypeManager.IsDelegateType (MemberType)) { Report.Error (66, Location, "`{0}': event must be of a delegate type", GetSignatureForError ()); - return false; } - parameters = Parameters.CreateFullyResolved ( - new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location)); + parameters = ParametersCompiled.CreateFullyResolved ( + new Parameter (null, "value", Parameter.Modifier.NONE, null, Location), MemberType); if (!CheckBase ()) return false; @@ -7339,8 +7400,8 @@ namespace Mono.CSharp { if (mi == null) return null; - ParameterData pd = TypeManager.GetParameterData (mi); - base_ret_type = pd.ParameterType (0); + AParametersCollection pd = TypeManager.GetParameterData (mi); + base_ret_type = pd.Types [0]; return mi; } @@ -7357,26 +7418,23 @@ namespace Mono.CSharp { { public class GetIndexerMethod : GetMethod { - Parameters parameters; + ParametersCompiled parameters; - public GetIndexerMethod (PropertyBase method): + public GetIndexerMethod (Indexer method): base (method) { + this.parameters = method.parameters; } public GetIndexerMethod (PropertyBase method, Accessor accessor): base (method, accessor) { + parameters = accessor.Parameters; } public override MethodBuilder Define (DeclSpace parent) { - // - // Clone indexer accessor parameters for localized capturing - // - if (!IsDummy) - parameters = ((Indexer) method).parameters.Clone (); - + parameters.Resolve (this); return base.Define (parent); } @@ -7390,7 +7448,7 @@ namespace Mono.CSharp { return false; } - public override Parameters ParameterInfo { + public override ParametersCompiled ParameterInfo { get { return parameters; } @@ -7399,22 +7457,18 @@ namespace Mono.CSharp { public class SetIndexerMethod: SetMethod { - public SetIndexerMethod (PropertyBase method): + public SetIndexerMethod (Indexer method): base (method) { + parameters = ParametersCompiled.MergeGenerated (method.parameters, false, parameters [0], null); } public SetIndexerMethod (PropertyBase method, Accessor accessor): base (method, accessor) { + parameters = method.Get.IsDummy ? accessor.Parameters : accessor.Parameters.Clone (); } - protected override void DefineParameters () - { - parameters = Parameters.MergeGenerated (((Indexer)method).parameters, - new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, method.Location)); - } - public override bool EnableOverloadChecks (MemberCore overload) { if (base.EnableOverloadChecks (overload)) { @@ -7423,7 +7477,7 @@ namespace Mono.CSharp { } return false; - } + } } const int AllowedModifiers = @@ -7442,10 +7496,10 @@ namespace Mono.CSharp { const int AllowedInterfaceModifiers = Modifiers.NEW; - public readonly Parameters parameters; + public readonly ParametersCompiled parameters; public Indexer (DeclSpace parent, FullNamedExpression type, MemberName name, int mod, - Parameters parameters, Attributes attrs, + ParametersCompiled parameters, Attributes attrs, Accessor get_block, Accessor set_block, bool define_set_first) : base (parent, type, mod, parent.PartialContainer.Kind == Kind.Interface ? AllowedInterfaceModifiers : AllowedModifiers, @@ -7463,20 +7517,22 @@ namespace Mono.CSharp { else Set = new SetIndexerMethod (this, set_block); } + + protected override bool CheckForDuplications () + { + return Parent.MemberCache.CheckExistingMembersOverloads (this, GetFullName (MemberName), parameters); + } public override bool Define () { - if (!DoDefineBase ()) - return false; - if (!base.Define ()) return false; if (!DefineParameters (parameters)) return false; - if (OptAttributes != null && TypeManager.indexer_name_type != null) { - Attribute indexer_attr = OptAttributes.Search (TypeManager.indexer_name_type); + if (OptAttributes != null) { + Attribute indexer_attr = OptAttributes.Search (PredefinedAttributes.Get.IndexerName); if (indexer_attr != null) { // Remove the attribute from the list because it is not emitted OptAttributes.Attrs.Remove (indexer_attr); @@ -7512,11 +7568,6 @@ namespace Mono.CSharp { !Parent.PartialContainer.AddMember (Get) || !Parent.PartialContainer.AddMember (Set)) return false; - if ((caching_flags & Flags.MethodOverloadsExist) != 0) { - if (!Parent.MemberCache.CheckExistingMembersOverloads (this, Name, parameters)) - return false; - } - flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName; if (!DefineAccessors ()) @@ -7529,7 +7580,7 @@ namespace Mono.CSharp { // Now name the parameters // PropertyBuilder = Parent.TypeBuilder.DefineProperty ( - GetFullName (MemberName), PropertyAttributes.None, MemberType, parameters.Types); + GetFullName (MemberName), PropertyAttributes.None, MemberType, parameters.GetEmitTypes ()); if (!Get.IsDummy) { PropertyBuilder.SetGetMethod (GetBuilder); @@ -7541,7 +7592,7 @@ namespace Mono.CSharp { Parent.MemberCache.AddMember (SetBuilder, Set); } - TypeManager.RegisterIndexer (PropertyBuilder, parameters.Types); + TypeManager.RegisterIndexer (PropertyBuilder, parameters); Parent.MemberCache.AddMember (PropertyBuilder, this); return true; } @@ -7553,7 +7604,7 @@ namespace Mono.CSharp { return true; } - return false; + return base.EnableOverloadChecks (overload); } public override string GetDocCommentName (DeclSpace ds) @@ -7577,7 +7628,7 @@ namespace Mono.CSharp { protected override PropertyInfo ResolveBaseProperty () { return Parent.PartialContainer.BaseCache.FindMemberToOverride ( - Parent.TypeBuilder, Name, parameters.Types, null, true) as PropertyInfo; + Parent.TypeBuilder, Name, parameters, null, true) as PropertyInfo; } protected override bool VerifyClsCompliance () @@ -7675,23 +7726,23 @@ namespace Mono.CSharp { } public Operator (DeclSpace parent, OpType type, FullNamedExpression ret_type, - int mod_flags, Parameters parameters, + int mod_flags, ParametersCompiled parameters, ToplevelBlock block, Attributes attrs, Location loc) : base (parent, null, ret_type, mod_flags, AllowedModifiers, - new MemberName ("op_" + type.ToString(), loc), attrs, parameters) + new MemberName (GetMetadataName (type), loc), attrs, parameters) { OperatorType = type; Block = block; } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.conditional_attribute_type) { + if (a.Type == pa.Conditional) { Error_ConditionalAttributeIsNotValid (); return; } - base.ApplyAttributeBuilder (a, cb); + base.ApplyAttributeBuilder (a, cb, pa); } public override bool Define () @@ -7699,7 +7750,6 @@ namespace Mono.CSharp { const int RequiredModifiers = Modifiers.PUBLIC | Modifiers.STATIC; if ((ModFlags & RequiredModifiers) != RequiredModifiers){ Report.Error (558, Location, "User-defined operator `{0}' must be declared static and public", GetSignatureForError ()); - return false; } if (!base.Define ()) @@ -7711,22 +7761,25 @@ namespace Mono.CSharp { else if (OperatorType == OpType.Implicit) Parent.MemberCache.CheckExistingMembersOverloads (this, GetMetadataName (OpType.Explicit), Parameters); - if (MemberType == TypeManager.void_type) { - Report.Error (590, Location, "User-defined operators cannot return void"); - return false; - } - Type declaring_type = MethodData.DeclaringType; Type return_type = MemberType; Type first_arg_type = ParameterTypes [0]; Type first_arg_type_unwrap = first_arg_type; if (TypeManager.IsNullableType (first_arg_type)) - first_arg_type_unwrap = TypeManager.GetTypeArguments (first_arg_type) [0]; + first_arg_type_unwrap = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (first_arg_type) [0]); Type return_type_unwrap = return_type; if (TypeManager.IsNullableType (return_type)) - return_type_unwrap = TypeManager.GetTypeArguments (return_type) [0]; + return_type_unwrap = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (return_type) [0]); + + if (TypeManager.IsDynamicType (return_type) || TypeManager.IsDynamicType (first_arg_type)) { + Report.Error (1964, Location, + "User-defined operator `{0}' cannot convert to or from the dynamic type", + GetSignatureForError ()); + + return false; + } // // Rules for conversion operators @@ -7774,7 +7827,7 @@ namespace Mono.CSharp { } } } else if (OperatorType == OpType.LeftShift || OperatorType == OpType.RightShift) { - if (first_arg_type != declaring_type || ParameterTypes [1] != TypeManager.int32_type) { + if (first_arg_type != declaring_type || Parameters.Types [1] != TypeManager.int32_type) { Report.Error (564, Location, "Overloaded shift operator must have the type of the first operand be the containing type, and the type of the second operand must be int"); return false; } @@ -7814,7 +7867,7 @@ namespace Mono.CSharp { // Checks for Binary operators if (first_arg_type != declaring_type && - ParameterTypes [1] != declaring_type){ + Parameters.Types [1] != declaring_type){ Report.Error ( 563, Location, "One of the parameters of a binary operator must " + @@ -7826,41 +7879,14 @@ namespace Mono.CSharp { return true; } - protected override bool DoDefine () + protected override bool ResolveMemberType () { - if (!base.DoDefine ()) + if (!base.ResolveMemberType ()) return false; flags |= MethodAttributes.SpecialName | MethodAttributes.HideBySig; return true; } - - public override void Emit () - { - base.Emit (); - - Parameters.ApplyAttributes (MethodBuilder); - - // - // abstract or extern methods have no bodies - // - if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0) - return; - - EmitContext ec; - if ((flags & MethodAttributes.PinvokeImpl) == 0) - ec = CreateEmitContext (Parent, MethodBuilder.GetILGenerator ()); - else - ec = CreateEmitContext (Parent, null); - - SourceMethod source = SourceMethod.Create (Parent, MethodBuilder, Block); - ec.EmitTopBlock (this, Block); - - if (source != null) - source.CloseMethod (); - - Block = null; - } // Operator cannot be override protected override MethodInfo FindOutBaseMethod (ref Type base_ret_type) @@ -7899,24 +7925,24 @@ namespace Mono.CSharp { public OpType GetMatchingOperator () { switch (OperatorType) { - case OpType.Equality: - return OpType.Inequality; - case OpType.Inequality: - return OpType.Equality; - case OpType.True: - return OpType.False; - case OpType.False: - return OpType.True; - case OpType.GreaterThan: - return OpType.LessThan; - case OpType.LessThan: - return OpType.GreaterThan; - case OpType.GreaterThanOrEqual: - return OpType.LessThanOrEqual; - case OpType.LessThanOrEqual: - return OpType.GreaterThanOrEqual; - default: - return OpType.TOP; + case OpType.Equality: + return OpType.Inequality; + case OpType.Inequality: + return OpType.Equality; + case OpType.True: + return OpType.False; + case OpType.False: + return OpType.True; + case OpType.GreaterThan: + return OpType.LessThan; + case OpType.LessThan: + return OpType.GreaterThan; + case OpType.GreaterThanOrEqual: + return OpType.LessThanOrEqual; + case OpType.LessThanOrEqual: + return OpType.GreaterThanOrEqual; + default: + return OpType.TOP; } } @@ -8043,7 +8069,7 @@ namespace Mono.CSharp { if (mi != null) args = TypeManager.GetParameterData (mi).Types; else - args = TypeManager.GetArgumentTypes (pi); + args = TypeManager.GetParameterData (pi).Types; Type [] sigp = sig.Parameters; if (args.Length != sigp.Length)