The logic was wrong here, it worked because of a codepath not covered, fixes #57895

[mono.git] / mcs / mcs / enum.cs

diff --git a/mcs/mcs/enum.cs b/mcs/mcs/enum.cs
index c6f613bfadff70ecc972304d77c7c3a8f5f0c36e..32d0bf91c9ec3c577b81b3f85368533886e85ea1 100755 (executable)
--- a/mcs/mcs/enum.cs
+++ b/mcs/mcs/enum.cs
@@ -23,7 +23,6 @@ namespace Mono.CSharp {
                ArrayList ordered_enums;
                
                public Expression BaseType;
-               public Attributes  OptAttributes;
                
                public Type UnderlyingType;
 
@@ -49,13 +48,13 @@ namespace Mono.CSharp {
                        Modifiers.INTERNAL |
                        Modifiers.PRIVATE;
 
-               public Enum (TypeContainer parent, Expression type, int mod_flags, string name, Attributes attrs, Location l)
-                       : base (parent, name, l)
+               public Enum (NamespaceEntry ns, TypeContainer parent, Expression type, int mod_flags,
+                            string name, Attributes attrs, Location l)
+                       : base (ns, parent, name, attrs, l)
                {
                        this.BaseType = type;
                        ModFlags = Modifiers.Check (AllowedModifiers, mod_flags,
                                                    IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE, l);
-                       OptAttributes = attrs;
 
                        ordered_enums = new ArrayList ();
                        member_to_location = new Hashtable ();
@@ -92,6 +91,11 @@ namespace Mono.CSharp {
                        return AdditionResult.Success;
                }
 
+               public override void ApplyAttributeBuilder (object builder, Attribute a, CustomAttributeBuilder cb)
+               {
+                       ((TypeBuilder) builder).SetCustomAttribute (cb);
+               }
+
                //
                // This is used by corlib compilation: we map from our
                // type to a type that is consumable by the DefineField
@@ -142,10 +146,9 @@ namespace Mono.CSharp {
                            UnderlyingType != TypeManager.short_type &&
                            UnderlyingType != TypeManager.ushort_type &&
                            UnderlyingType != TypeManager.byte_type  &&
-                           UnderlyingType != TypeManager.char_type  &&
                            UnderlyingType != TypeManager.sbyte_type) {
                                Report.Error (1008, Location,
-                                             "Type byte, sbyte, short, char, ushort, int, uint, " +
+                                             "Type byte, sbyte, short, ushort, int, uint, " +
                                              "long, or ulong expected (got: " +
                                              TypeManager.CSharpName (UnderlyingType) + ")");
                                return null;
@@ -155,7 +158,7 @@ namespace Mono.CSharp {
                                if (TypeManager.NamespaceClash (Name, Location))
                                        return null;
                                
-                               ModuleBuilder builder = CodeGen.ModuleBuilder;
+                               ModuleBuilder builder = CodeGen.Module.Builder;
 
                                TypeBuilder = builder.DefineType (Name, attr, TypeManager.enum_type);
                        } else {
@@ -603,12 +606,61 @@ namespace Mono.CSharp {
 
                                default_value = GetNextDefaultValue (default_value);
                        }
+                       return true;
+               }
                        
-                       Attribute.ApplyAttributes (ec, TypeBuilder, this, OptAttributes);
+               public override void Emit (TypeContainer tc)
+               {
+                       if (OptAttributes != null) {
+                               EmitContext ec = new EmitContext (tc, this, Location, null, null, ModFlags, false);
+                               Attribute.ApplyAttributes (ec, TypeBuilder, this, OptAttributes);
+                       }
+
+                       base.Emit (tc);
+               }
+               
+               protected override bool IsIdentifierClsCompliant (DeclSpace ds)
+               {
+                       if (!base.IsIdentifierClsCompliant (ds))
+                               return false;
+
+                       for (int i = 1; i < ordered_enums.Count; ++i) {
+                               string checked_name = ordered_enums [i] as string;
+                               for (int ii = 0; ii < ordered_enums.Count; ++ii) {
+                                       if (ii == i)
+                                               continue;
+
+                                       string enumerator_name = ordered_enums [ii] as string;
+                                       if (String.Compare (checked_name, enumerator_name, true) == 0) {
+                                               Report.SymbolRelatedToPreviousError ((Location)member_to_location [enumerator_name], enumerator_name);
+                                               Report.Error_T (3005, (Location)member_to_location [checked_name], GetEnumeratorName (checked_name));
+                                               break;
+                                       }
+                               }
+                       }
+                       return true;
+               }
+
+               protected override bool VerifyClsCompliance (DeclSpace ds)
+               {
+                       if (!base.VerifyClsCompliance (ds))
+                               return false;
+
+                       if (!AttributeTester.IsClsCompliant (UnderlyingType)) {
+                               Report.Error_T (3009, Location, GetSignatureForError (), TypeManager.CSharpName (UnderlyingType));
+                       }
 
                        return true;
                }
                
+               /// <summary>
+               /// Returns full enum name.
+               /// </summary>
+               string GetEnumeratorName (string valueName)
+               {
+                       return String.Concat (Name, ".", valueName);
+               }
+
                //
                // IMemberFinder
                //