Implemented PipeSecurity. GetAccessControl, SetAccessControl, and ACL-containing...

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

diff --git a/mcs/mcs/typespec.cs b/mcs/mcs/typespec.cs
index fa642d394edf30e2b47c98cf3a1c63be3e772c34..8337ce59b8d91eb89391baa3908d53184c1b6659 100644 (file)
--- a/mcs/mcs/typespec.cs
+++ b/mcs/mcs/typespec.cs
@@ -23,6 +23,9 @@ using System.Reflection;
 
 namespace Mono.CSharp
 {
+       //
+       // Inflated or non-inflated representation of any type. 
+       //
        public class TypeSpec : MemberSpec
        {
                protected MetaType info;
@@ -292,7 +295,7 @@ namespace Mono.CSharp
                                if (IsPointer)
                                        return ((ElementTypeSpec) this).Element.IsUnmanaged;
 
-                               var ds = MemberDefinition as TypeContainer;
+                               var ds = MemberDefinition as TypeDefinition;
                                if (ds != null)
                                        return ds.IsUnmanagedType ();
 
@@ -306,6 +309,9 @@ namespace Mono.CSharp
                        }
                }
 
+               //
+               // A cache of all type members (including nested types)
+               //
                public MemberCache MemberCache {
                        get {
                                if (cache == null || (state & StateFlags.PendingMemberCacheMembers) != 0)
@@ -435,6 +441,9 @@ namespace Mono.CSharp
                        return aua;
                }
 
+               //
+               // Return metadata information used during emit to describe the type
+               //
                public virtual MetaType GetMetaInfo ()
                {
                        return info;
@@ -445,6 +454,9 @@ namespace Mono.CSharp
                        return this;
                }
 
+               //
+               // Text representation of type used by documentation writer
+               //
                public override string GetSignatureForDocumentation ()
                {
                        StringBuilder sb = new StringBuilder ();
@@ -651,6 +663,9 @@ namespace Mono.CSharp
                        return new InflatedTypeSpec (inflator.Context, this, inflator.TypeInstance, targs);
                }
 
+               //
+               // Inflates current type using specific type arguments
+               //
                public InflatedTypeSpec MakeGenericType (IModuleContext context, TypeSpec[] targs)
                {
                        if (targs.Length == 0 && !IsNested)
@@ -721,6 +736,18 @@ namespace Mono.CSharp
                                }
                        }
 
+                       if (MemberDefinition.TypeParametersCount > 0) {
+                               foreach (var tp in MemberDefinition.TypeParameters) {
+                                       var tp_missing = tp.GetMissingDependencies ();
+                                       if (tp_missing != null) {
+                                               if (missing == null)
+                                                       missing = new List<TypeSpec> ();
+
+                                               missing.AddRange (tp_missing);
+                                       }
+                               }
+                       }
+
                        if (missing != null || BaseType == null)
                                return missing;
 
@@ -741,6 +768,10 @@ namespace Mono.CSharp
                }
        }
 
+       //
+       // Special version used for types which must exist in corlib or
+       // the compiler cannot work
+       //
        public sealed class BuiltinTypeSpec : TypeSpec
        {
                public enum Type
@@ -922,6 +953,9 @@ namespace Mono.CSharp
                }
        }
 
+       //
+       // Various type comparers used by compiler
+       //
        static class TypeSpecComparer
        {
                //
@@ -1061,8 +1095,7 @@ namespace Mono.CSharp
                                        if (!IsEqual (a.Types[i], b.Types[i]))
                                                return false;
 
-                                       const Parameter.Modifier ref_out = Parameter.Modifier.REF | Parameter.Modifier.OUT;
-                                       if ((a.FixedParameters[i].ModFlags & ref_out) != (b.FixedParameters[i].ModFlags & ref_out))
+                                       if ((a.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != (b.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask))
                                                return false;
                                }
 
@@ -1303,6 +1336,7 @@ namespace Mono.CSharp
        {
                IAssemblyDefinition DeclaringAssembly { get; }
                string Namespace { get; }
+               bool IsPartial { get; }
                int TypeParametersCount { get; }
                TypeParameterSpec[] TypeParameters { get; }
 
@@ -1325,12 +1359,6 @@ namespace Mono.CSharp
 
                readonly string name;
 
-               InternalType (string name, MemberCache cache)
-                       : this (name)
-               {
-                       this.cache = cache;
-               }
-
                InternalType (string name)
                        : base (MemberKind.InternalCompilerType, null, null, null, Modifiers.PUBLIC)
                {
@@ -1339,7 +1367,7 @@ namespace Mono.CSharp
                        cache = MemberCache.Empty;
 
                        // Make all internal types CLS-compliant, non-obsolete
-                       state = (state & ~(StateFlags.CLSCompliant_Undetected | StateFlags.Obsolete_Undetected)) | StateFlags.CLSCompliant;
+                       state = (state & ~(StateFlags.CLSCompliant_Undetected | StateFlags.Obsolete_Undetected | StateFlags.MissingDependency_Undetected)) | StateFlags.CLSCompliant;
                }
 
                #region Properties
@@ -1362,6 +1390,12 @@ namespace Mono.CSharp
                        }
                }
 
+               bool ITypeDefinition.IsPartial {
+                       get {
+                               return false;
+                       }
+               }
+
                public override string Name {
                        get {
                                return name;
@@ -1447,6 +1481,9 @@ namespace Mono.CSharp
                #endregion
        }
 
+       //
+       // Common base class for composite types
+       //
        public abstract class ElementTypeSpec : TypeSpec, ITypeDefinition
        {
                protected ElementTypeSpec (MemberKind kind, TypeSpec element, MetaType info)
@@ -1454,11 +1491,8 @@ namespace Mono.CSharp
                {
                        this.Element = element;
 
-                       // Some flags can be copied directly from the element
-                       const StateFlags shared_flags = StateFlags.CLSCompliant | StateFlags.CLSCompliant_Undetected
-                               | StateFlags.Obsolete | StateFlags.Obsolete_Undetected | StateFlags.HasDynamicElement;
-                       state &= ~shared_flags;
-                       state |= (element.state & shared_flags);
+                       state &= ~SharedStateFlags;
+                       state |= (element.state & SharedStateFlags);
 
                        if (element.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
                                state |= StateFlags.HasDynamicElement;
@@ -1474,6 +1508,12 @@ namespace Mono.CSharp
 
                public TypeSpec Element { get; private set; }
 
+               bool ITypeDefinition.IsPartial {
+                       get {
+                               return false;
+                       }
+               }
+
                public override string Name {
                        get {
                                throw new NotSupportedException ();