X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fdecl.cs;h=6b341f0de709f57eaea7ab56f55ae425ca5b0d56;hb=24b2c4de33c81f823f3da28ccf5a8e12f560820d;hp=4a4c03f4317eaeb23e60259c8de24df3ee448ab6;hpb=217ddc29c40bc8b11f8fbd4800e61db7f4f22bbf;p=mono.git diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs index 4a4c03f4317..6b341f0de70 100644 --- a/mcs/mcs/decl.cs +++ b/mcs/mcs/decl.cs @@ -349,14 +349,21 @@ namespace Mono.CSharp { } } else { if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN | Modifiers.PARTIAL)) == 0) { - if (RootContext.Version >= LanguageVersion.LINQ && this is Property.PropertyMethod && - !(this is Indexer.GetIndexerMethod || this is Indexer.SetIndexerMethod)) { - Report.Error (840, Location, "`{0}' must have a body because it is not marked abstract or extern. The property can be automatically implemented when you define both accessors", - GetSignatureForError ()); - } else { - Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract, extern, or partial", - GetSignatureForError ()); + if (RootContext.Version >= LanguageVersion.V_3) { + Property.PropertyMethod pm = this as Property.PropertyMethod; + if (pm is Indexer.GetIndexerMethod || pm is Indexer.SetIndexerMethod) + pm = null; + + if (pm != null && (pm.Property.Get.IsDummy || pm.Property.Set.IsDummy)) { + Report.Error (840, Location, + "`{0}' must have a body because it is not marked abstract or extern. The property can be automatically implemented when you define both accessors", + GetSignatureForError ()); + return false; + } } + + Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract, extern, or partial", + GetSignatureForError ()); return false; } } @@ -381,8 +388,8 @@ namespace Mono.CSharp { return; } - if (((Parent.ModFlags & Modifiers.SEALED) != 0) && - ((ModFlags & Modifiers.OVERRIDE) == 0) && (Name != "Finalize")) { + if ((Parent.ModFlags & Modifiers.SEALED) != 0 && (ModFlags & Modifiers.OVERRIDE) == 0 && + !(this is Destructor)) { Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ()); return; @@ -451,10 +458,10 @@ namespace Mono.CSharp { caching_flags &= ~Flags.Obsolete_Undetected; - if (OptAttributes == null || TypeManager.obsolete_attribute_type == null) + if (OptAttributes == null) return null; - Attribute obsolete_attr = OptAttributes.Search (TypeManager.obsolete_attribute_type); + Attribute obsolete_attr = OptAttributes.Search (PredefinedAttributes.Get.Obsolete); if (obsolete_attr == null) return null; @@ -550,17 +557,15 @@ namespace Mono.CSharp { while (TypeManager.HasElementType (p)) p = TypeManager.GetElementType (p); -#if GMCS_SOURCE - if (p.IsGenericParameter) + if (TypeManager.IsGenericParameter (p)) return true; if (TypeManager.IsGenericType (p)) { - foreach (Type t in p.GetGenericArguments ()) { + foreach (Type t in TypeManager.GetTypeArguments (p)) { if (!IsAccessibleAs (t)) return false; } } -#endif for (Type p_parent = null; p != null; p = p_parent) { p_parent = p.DeclaringType; @@ -676,9 +681,9 @@ namespace Mono.CSharp { caching_flags &= ~Flags.HasCompliantAttribute_Undetected; - if (OptAttributes != null && TypeManager.cls_compliant_attribute_type != null) { + if (OptAttributes != null) { Attribute cls_attribute = OptAttributes.Search ( - TypeManager.cls_compliant_attribute_type); + PredefinedAttributes.Get.CLSCompliant); if (cls_attribute != null) { caching_flags |= Flags.HasClsCompliantAttribute; bool value = cls_attribute.GetClsCompliantAttributeValue (); @@ -729,24 +734,31 @@ namespace Mono.CSharp { { if (!IsClsComplianceRequired ()) { if (HasClsCompliantAttribute && Report.WarningLevel >= 2) { - if (!IsExposedFromAssembly ()) - Report.Warning (3019, 2, Location, "CLS compliance checking will not be performed on `{0}' because it is not visible from outside this assembly", GetSignatureForError ()); - if (!CodeGen.Assembly.IsClsCompliant) - Report.Warning (3021, 2, Location, "`{0}' does not need a CLSCompliant attribute because the assembly is not marked as CLS-compliant", GetSignatureForError ()); + if (!IsExposedFromAssembly ()) { + Attribute a = OptAttributes.Search (PredefinedAttributes.Get.CLSCompliant); + Report.Warning (3019, 2, a.Location, "CLS compliance checking will not be performed on `{0}' because it is not visible from outside this assembly", GetSignatureForError ()); + } + + if (!CodeGen.Assembly.IsClsCompliant) { + Attribute a = OptAttributes.Search (PredefinedAttributes.Get.CLSCompliant); + Report.Warning (3021, 2, a.Location, "`{0}' does not need a CLSCompliant attribute because the assembly is not marked as CLS-compliant", GetSignatureForError ()); + } } return false; } if (HasClsCompliantAttribute) { if (CodeGen.Assembly.ClsCompliantAttribute == null && !CodeGen.Assembly.IsClsCompliant) { - Report.Warning (3014, 1, Location, + Attribute a = OptAttributes.Search (PredefinedAttributes.Get.CLSCompliant); + Report.Warning (3014, 1, a.Location, "`{0}' cannot be marked as CLS-compliant because the assembly is not marked as CLS-compliant", GetSignatureForError ()); return false; } if (!Parent.IsClsComplianceRequired ()) { - Report.Warning (3018, 1, Location, "`{0}' cannot be marked as CLS-compliant because it is a member of non CLS-compliant type `{1}'", + Attribute a = OptAttributes.Search (PredefinedAttributes.Get.CLSCompliant); + Report.Warning (3018, 1, a.Location, "`{0}' cannot be marked as CLS-compliant because it is a member of non CLS-compliant type `{1}'", GetSignatureForError (), Parent.GetSignatureForError ()); return false; } @@ -864,6 +876,8 @@ namespace Mono.CSharp { protected readonly bool is_generic; readonly int count_type_params; + protected TypeParameter[] type_params; + TypeParameter[] type_param_list; // // Whether we are Generic @@ -913,6 +927,9 @@ namespace Mono.CSharp { return true; } + if (((mc.ModFlags | symbol.ModFlags) & Modifiers.COMPILER_GENERATED) != 0) + return true; + if (symbol.EnableOverloadChecks (mc)) return true; @@ -922,7 +939,7 @@ namespace Mono.CSharp { return false; } - if (this is RootTypes) { + if (this is ModuleContainer) { Report.Error (101, symbol.Location, "The namespace `{0}' already contains a definition for `{1}'", ((DeclSpace)symbol).NamespaceEntry.GetSignatureForError (), symbol.MemberName.Name); @@ -966,6 +983,11 @@ namespace Mono.CSharp { get { return (Parent != null && Parent.Parent == null); } } + public virtual bool IsUnmanagedType () + { + return false; + } + public virtual void CloseType () { if ((caching_flags & Flags.CloseTypeCreated) == 0){ @@ -988,7 +1010,7 @@ namespace Mono.CSharp { } protected virtual TypeAttributes TypeAttr { - get { return CodeGen.Module.DefaultCharSetType; } + get { return Module.DefaultCharSetType; } } /// @@ -1005,7 +1027,6 @@ namespace Mono.CSharp { public override void Emit () { -#if GMCS_SOURCE if (type_params != null) { int offset = count_type_params - type_params.Length; for (int i = offset; i < type_params.Length; i++) @@ -1013,8 +1034,7 @@ namespace Mono.CSharp { } if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated) - TypeBuilder.SetCustomAttribute (TypeManager.GetCompilerGeneratedAttribute (Location)); -#endif + PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (TypeBuilder); base.Emit (); } @@ -1026,8 +1046,8 @@ namespace Mono.CSharp { public bool CheckAccessLevel (Type check_type) { - TypeBuilder tb = TypeBuilder; -#if GMCS_SOURCE + Type tb = TypeBuilder; + if (this is GenericMethod) { tb = Parent.TypeBuilder; @@ -1036,18 +1056,22 @@ namespace Mono.CSharp { if (TypeBuilder == null) return true; } -#endif check_type = TypeManager.DropGenericTypeArguments (check_type); if (check_type == tb) return true; + // TODO: When called from LocalUsingAliasEntry tb is null + // because we are in RootDeclSpace + if (tb == null) + tb = typeof (RootDeclSpace); + // // Broken Microsoft runtime, return public for arrays, no matter what // the accessibility is for their underlying class, and they return // NonPublic visibility for pointers // - if (check_type.IsArray || check_type.IsPointer) + if (TypeManager.HasElementType (check_type)) return CheckAccessLevel (TypeManager.GetElementType (check_type)); TypeAttributes check_attr = check_type.Attributes & TypeAttributes.VisibilityMask; @@ -1147,7 +1171,6 @@ namespace Mono.CSharp { if ((t == null) || !CheckAccessLevel (t)) continue; -#if GMCS_SOURCE if (!TypeManager.IsGenericType (current_type)) return t; @@ -1156,6 +1179,7 @@ namespace Mono.CSharp { for (int i = 0; i < args.Length; i++) targs [i] = args [i]; +#if GMCS_SOURCE t = t.MakeGenericType (targs); #endif @@ -1219,21 +1243,19 @@ namespace Mono.CSharp { get; } - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb) + public virtual ModuleContainer Module { + get { return Parent.Module; } + } + + public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa) { - if (a.Type == TypeManager.required_attr_type) { + if (a.Type == pa.Required) { Report.Error (1608, a.Location, "The RequiredAttribute attribute is not permitted on C# types"); return; } TypeBuilder.SetCustomAttribute (cb); } - // - // Extensions for generics - // - protected TypeParameter[] type_params; - TypeParameter[] type_param_list; - TypeParameter[] initialize_type_params () { if (type_param_list != null) @@ -1312,9 +1334,14 @@ namespace Mono.CSharp { } } + Variance variance = name.Variance; + if (name.Variance != Variance.None && !(this is Delegate || this is Interface)) { + Report.Error (1960, name.Location, "Variant type parameters can only be used with interfaces and delegates"); + variance = Variance.None; + } + type_params [i] = new TypeParameter ( - Parent, this, name.Name, constraints, name.OptAttributes, - Location); + Parent, this, name.Name, constraints, name.OptAttributes, variance, Location); AddToContainer (type_params [i], name.Name); } @@ -2287,9 +2314,6 @@ namespace Mono.CSharp { return null; EntryType entry_type = EntryType.Static | EntryType.Method | EntryType.NotExtensionMethod; - if (publicOnly) { - entry_type |= EntryType.Public; - } EntryType found_entry_type = entry_type & ~EntryType.NotExtensionMethod; ArrayList candidates = null; @@ -2297,6 +2321,16 @@ namespace Mono.CSharp { if ((entry.EntryType & entry_type) == found_entry_type) { MethodBase mb = (MethodBase)entry.Member; + // Simple accessibility check + if ((entry.EntryType & EntryType.Public) == 0 && publicOnly) { + MethodAttributes ma = mb.Attributes & MethodAttributes.MemberAccessMask; + if (ma != MethodAttributes.Assembly && ma != MethodAttributes.FamORAssem) + continue; + + if (!TypeManager.IsThisOrFriendAssembly (mb.DeclaringType.Assembly)) + continue; + } + IMethodData md = TypeManager.GetMethod (mb); AParametersCollection pd = md == null ? TypeManager.GetParameterData (mb) : md.ParameterInfo; @@ -2353,7 +2387,7 @@ namespace Mono.CSharp { if (is_property) { if ((entry.EntryType & EntryType.Field) != 0) { fi = (FieldInfo)entry.Member; - cmp_attrs = Parameters.EmptyReadOnlyParameters; + cmp_attrs = ParametersCompiled.EmptyReadOnlyParameters; } else { pi = (PropertyInfo) entry.Member; cmp_attrs = TypeManager.GetParameterData (pi); @@ -2383,7 +2417,7 @@ namespace Mono.CSharp { // // Check for assembly methods // - if (mi.DeclaringType.Assembly != CodeGen.Assembly.Builder) + if (fi.DeclaringType.Assembly != CodeGen.Assembly.Builder) continue; break; } @@ -2621,7 +2655,7 @@ namespace Mono.CSharp { } } - public bool CheckExistingMembersOverloads (MemberCore member, string name, Parameters parameters) + public bool CheckExistingMembersOverloads (MemberCore member, string name, ParametersCompiled parameters) { ArrayList entries = (ArrayList)member_hash [name]; if (entries == null) @@ -2641,12 +2675,12 @@ namespace Mono.CSharp { p_types = pd.Types; } else { MethodBase mb = (MethodBase) ce.Member; -#if GMCS_SOURCE + // TODO: This is more like a hack, because we are adding generic methods // twice with and without arity name - if (mb.IsGenericMethod && !member.MemberName.IsGeneric) + if (TypeManager.IsGenericMethod (mb) && !member.MemberName.IsGeneric) continue; -#endif + pd = TypeManager.GetParameterData (mb); p_types = pd.Types; } @@ -2662,11 +2696,11 @@ namespace Mono.CSharp { type_b = p_types [ii]; #if GMCS_SOURCE - if (type_a.IsGenericParameter && type_a.DeclaringMethod != null) - type_a = null; + if (TypeManager.IsGenericParameter (type_a) && type_a.DeclaringMethod != null) + type_a = typeof (TypeParameter); - if (type_b.IsGenericParameter && type_b.DeclaringMethod != null) - type_b = null; + if (TypeManager.IsGenericParameter (type_b) && type_b.DeclaringMethod != null) + type_b = typeof (TypeParameter); #endif if ((pd.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF) != (parameters.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF)) @@ -2706,9 +2740,15 @@ namespace Mono.CSharp { "A partial method declaration and partial method implementation must be both an extension method or neither"); } } else { - Report.Error (663, member.Location, - "An overloaded method `{0}' cannot differ on use of parameter modifiers only", - member.GetSignatureForError ()); + if (member is Constructor) { + Report.Error (851, member.Location, + "Overloaded contructor `{0}' cannot differ on use of parameter modifiers only", + member.GetSignatureForError ()); + } else { + Report.Error (663, member.Location, + "Overloaded method `{0}' cannot differ on use of parameter modifiers only", + member.GetSignatureForError ()); + } } return false; }