Merge pull request #1072 from esdrubal/bug19862

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

diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs
index 866186eb3a98ed23aaa7c4e7831e66c6769323a7..56d423ad23d6ccb754014c5a28a574cb027f69f1 100644 (file)
--- a/mcs/mcs/decl.cs
+++ b/mcs/mcs/decl.cs
@@ -293,7 +293,9 @@ namespace Mono.CSharp {
                        PartialDefinitionExists = 1 << 14,      // Set when corresponding partial method definition exists
                        HasStructLayout = 1 << 15,                      // Has StructLayoutAttribute
                        HasInstanceConstructor = 1 << 16,
-                       HasUserOperators = 1 << 17
+                       HasUserOperators = 1 << 17,
+                       CanBeReused = 1 << 18,
+                       InterfacesExpanded = 1 << 19
                }
 
                /// <summary>
@@ -301,7 +303,7 @@ namespace Mono.CSharp {
                /// </summary>
                internal Flags caching_flags;
 
-               public MemberCore (TypeContainer parent, MemberName name, Attributes attrs)
+               protected MemberCore (TypeContainer parent, MemberName name, Attributes attrs)
                {
                        this.Parent = parent;
                        member_name = name;
@@ -419,12 +421,21 @@ namespace Mono.CSharp {
                        VerifyClsCompliance ();
                }
 
+               public bool IsAvailableForReuse {
+                       get {
+                               return (caching_flags & Flags.CanBeReused) != 0;
+                       }
+                       set {
+                               caching_flags = value ? (caching_flags | Flags.CanBeReused) : (caching_flags & ~Flags.CanBeReused);
+                       }
+               }
+
                public bool IsCompilerGenerated {
                        get     {
                                if ((mod_flags & Modifiers.COMPILER_GENERATED) != 0)
                                        return true;
 
-                               return Parent == null ? false : Parent.IsCompilerGenerated;
+                               return Parent != null && Parent.IsCompilerGenerated;
                        }
                }
 
@@ -456,7 +467,7 @@ namespace Mono.CSharp {
                        caching_flags |= Flags.IsAssigned;
                }
 
-               public void SetConstraints (List<Constraints> constraints_list)
+               public virtual void SetConstraints (List<Constraints> constraints_list)
                {
                        var tparams = member_name.TypeParameters;
                        if (tparams == null) {
@@ -592,7 +603,7 @@ namespace Mono.CSharp {
                                                if (al == Modifiers.PRIVATE) {
                                                        var decl = mc.Parent;
                                                        do {
-                                                               same_access_restrictions = decl.CurrentType == p_parent;
+                                                               same_access_restrictions = decl.CurrentType.MemberDefinition == p_parent.MemberDefinition;
                                                        } while (!same_access_restrictions && !decl.PartialContainer.IsTopLevel && (decl = decl.Parent) != null);
                                                }
                                                
@@ -873,7 +884,7 @@ namespace Mono.CSharp {
                                if (GetAttributeObsolete () != null)
                                        return true;
 
-                               return Parent == null ? false : Parent.IsObsolete;
+                               return Parent != null && Parent.IsObsolete;
                        }
                }
 
@@ -882,7 +893,7 @@ namespace Mono.CSharp {
                                if ((ModFlags & Modifiers.UNSAFE) != 0)
                                        return true;
 
-                               return Parent == null ? false : Parent.IsUnsafe;
+                               return Parent != null && Parent.IsUnsafe;
                        }
                }
 
@@ -926,9 +937,19 @@ namespace Mono.CSharp {
                        InflatedExpressionType = 1 << 19,
                        InflatedNullableType = 1 << 20,
                        GenericIterateInterface = 1 << 21,
-                       GenericTask = 1 << 22
+                       GenericTask = 1 << 22,
+                       InterfacesImported = 1 << 23,
                }
 
+               //
+               // Some flags can be copied directly from other member
+               //
+               protected const StateFlags SharedStateFlags =
+                       StateFlags.CLSCompliant | StateFlags.CLSCompliant_Undetected |
+                       StateFlags.Obsolete | StateFlags.Obsolete_Undetected |
+                       StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected |
+                       StateFlags.HasDynamicElement;
+
                protected Modifiers modifiers;
                public StateFlags state;
                protected IMemberDefinition definition;
@@ -947,7 +968,10 @@ namespace Mono.CSharp {
                        this.definition = definition;
                        this.modifiers = modifiers;
 
-                       state = StateFlags.Obsolete_Undetected | StateFlags.CLSCompliant_Undetected | StateFlags.MissingDependency_Undetected;
+                       if (kind == MemberKind.MissingType)
+                               state = StateFlags.MissingDependency;
+                       else
+                               state = StateFlags.Obsolete_Undetected | StateFlags.CLSCompliant_Undetected | StateFlags.MissingDependency_Undetected;
                }
 
                #region Properties
@@ -1061,7 +1085,12 @@ namespace Mono.CSharp {
                // will contain types only but it can have numerous values for members
                // like methods where both return type and all parameters are checked
                //
-               public List<TypeSpec> GetMissingDependencies ()
+               public List<MissingTypeSpecReference> GetMissingDependencies ()
+               {
+                       return GetMissingDependencies (this);
+               }
+
+               public List<MissingTypeSpecReference> GetMissingDependencies (MemberSpec caller)
                {
                        if ((state & (StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected)) == 0)
                                return null;
@@ -1069,11 +1098,11 @@ namespace Mono.CSharp {
                        state &= ~StateFlags.MissingDependency_Undetected;
 
                        var imported = definition as ImportedDefinition;
-                       List<TypeSpec> missing;
+                       List<MissingTypeSpecReference> missing;
                        if (imported != null) {
-                               missing = ResolveMissingDependencies ();
+                               missing = ResolveMissingDependencies (caller);
                        } else if (this is ElementTypeSpec) {
-                               missing = ((ElementTypeSpec) this).Element.GetMissingDependencies ();
+                               missing = ((ElementTypeSpec) this).Element.GetMissingDependencies (caller);
                        } else {
                                missing = null;
                        }
@@ -1085,7 +1114,7 @@ namespace Mono.CSharp {
                        return missing;
                }
 
-               public abstract List<TypeSpec> ResolveMissingDependencies ();
+               public abstract List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller);
 
                protected virtual bool IsNotCLSCompliant (out bool attrValue)
                {
@@ -1137,7 +1166,7 @@ namespace Mono.CSharp {
                        var ctype = ctx.CurrentType;
 
                        if (ma == Modifiers.PRIVATE) {
-                               if (ctype == null)
+                               if (ctype == null || parentType == null)
                                        return false;
                                //
                                // It's only accessible to the current class or children
@@ -1203,7 +1232,7 @@ namespace Mono.CSharp {
                        return (state & StateFlags.CLSCompliant) != 0;
                }
 
-               public bool IsConditionallyExcluded (IMemberContext ctx, Location loc)
+               public bool IsConditionallyExcluded (IMemberContext ctx)
                {
                        if ((Kind & (MemberKind.Class | MemberKind.Method)) == 0)
                                return false;
@@ -1251,6 +1280,11 @@ namespace Mono.CSharp {
                void SetIsUsed ();
        }
 
+       public interface IMethodDefinition : IMemberDefinition
+       {
+               MethodBase Metadata { get; }
+       }
+
        public interface IParametersMember : IInterfaceMemberSpec
        {
                AParametersCollection Parameters { get; }