Improved DateTime parsing of years.

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

diff --git a/mcs/mcs/typespec.cs b/mcs/mcs/typespec.cs
index 2657956a2f540821f0d0b6332483790ef391a7ef..a33159d8478bdb6100faa7ba75f376290c667a5c 100644 (file)
--- a/mcs/mcs/typespec.cs
+++ b/mcs/mcs/typespec.cs
@@ -211,7 +211,7 @@ namespace Mono.CSharp
                //
                // Returns true for instances of IList<T>, IEnumerable<T>, ICollection<T>
                //
-               public virtual bool IsGenericIterateInterface {
+               public virtual bool IsArrayGenericInterface {
                        get {
                                return false;
                        }
@@ -295,6 +295,12 @@ namespace Mono.CSharp
                        }
                }
 
+               public bool IsStructOrEnum {
+                       get {
+                               return (Kind & (MemberKind.Struct | MemberKind.Enum)) != 0;
+                       }
+               }
+
                public bool IsTypeBuilder {
                        get {
 #if STATIC
@@ -321,6 +327,9 @@ namespace Mono.CSharp
                                if (Kind == MemberKind.Void)
                                        return true;
 
+                               if (Kind == MemberKind.TypeParameter)
+                                       return false;
+
                                if (IsNested && DeclaringType.IsGenericOrParentIsGeneric)
                                        return false;
 
@@ -375,7 +384,7 @@ namespace Mono.CSharp
                                throw new InternalErrorException ("Modifying expanded interface list");
 
                        if (ifaces == null) {
-                               ifaces = new List<TypeSpec> () { iface };
+                               ifaces = new List<TypeSpec> { iface };
                                return true;
                        }
 
@@ -642,6 +651,7 @@ namespace Mono.CSharp
                        case MemberKind.Struct:
                        case MemberKind.Enum:
                        case MemberKind.Void:
+                       case MemberKind.PointerType:
                                return false;
                        case MemberKind.InternalCompilerType:
                                //
@@ -653,6 +663,20 @@ namespace Mono.CSharp
                        }
                }
 
+               public static bool IsNonNullableValueType (TypeSpec t)
+               {
+                       switch (t.Kind) {
+                       case MemberKind.TypeParameter:
+                               return ((TypeParameterSpec) t).IsValueType;
+                       case MemberKind.Struct:
+                               return !t.IsNullableType;
+                       case MemberKind.Enum:
+                               return true;
+                       default:
+                               return false;
+                       }
+               }
+
                public static bool IsValueType (TypeSpec t)
                {
                        switch (t.Kind) {
@@ -724,22 +748,22 @@ namespace Mono.CSharp
                        return this;
                }
 
-               public override List<TypeSpec> ResolveMissingDependencies ()
+               public override List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller)
                {
-                       List<TypeSpec> missing = null;
+                       List<MissingTypeSpecReference> missing = null;
 
                        if (Kind == MemberKind.MissingType) {
-                               missing = new List<TypeSpec> ();
-                               missing.Add (this);
+                               missing = new List<MissingTypeSpecReference> ();
+                               missing.Add (new MissingTypeSpecReference (this, caller));
                                return missing;
                        }
 
                        foreach (var targ in TypeArguments) {
                                if (targ.Kind == MemberKind.MissingType) {
                                        if (missing == null)
-                                               missing = new List<TypeSpec> ();
+                                               missing = new List<MissingTypeSpecReference> ();
 
-                                       missing.Add (targ);
+                                       missing.Add (new MissingTypeSpecReference (targ, caller));
                                }
                        }
 
@@ -747,19 +771,19 @@ namespace Mono.CSharp
                                foreach (var iface in Interfaces) {
                                        if (iface.Kind == MemberKind.MissingType) {
                                                if (missing == null)
-                                                       missing = new List<TypeSpec> ();
+                                                       missing = new List<MissingTypeSpecReference> ();
 
-                                               missing.Add (iface);
+                                               missing.Add (new MissingTypeSpecReference (iface, caller));
                                        }
                                }
                        }
 
                        if (MemberDefinition.TypeParametersCount > 0) {
                                foreach (var tp in MemberDefinition.TypeParameters) {
-                                       var tp_missing = tp.GetMissingDependencies ();
+                                       var tp_missing = tp.GetMissingDependencies (this);
                                        if (tp_missing != null) {
                                                if (missing == null)
-                                                       missing = new List<TypeSpec> ();
+                                                       missing = new List<MissingTypeSpecReference> ();
 
                                                missing.AddRange (tp_missing);
                                        }
@@ -769,7 +793,7 @@ namespace Mono.CSharp
                        if (missing != null || BaseType == null)
                                return missing;
 
-                       return BaseType.ResolveMissingDependencies ();
+                       return BaseType.ResolveMissingDependencies (this);
                }
 
                public void SetMetaInfo (MetaType info)
@@ -784,6 +808,31 @@ namespace Mono.CSharp
                {
                        modifiers |= Modifiers.METHOD_EXTENSION;
                }
+
+               public void UpdateInflatedInstancesBaseType ()
+               {
+                       //
+                       // When nested class has a partial part the situation where parent type
+                       // is inflated before its base type is defined can occur. In such case
+                       // all inflated (should be only 1) instansted need to be updated
+                       //
+                       // partial class A<T> {
+                       //   partial class B : A<int> { }
+                       // }
+                       //
+                       // partial class A<T> : X {}
+                       //
+                       if (inflated_instances == null)
+                               return;
+
+                       foreach (var inflated in inflated_instances) {
+                               //
+                               // Don't need to inflate possible generic type because for now the method
+                               // is always used from within the nested type
+                               //
+                               inflated.Value.BaseType = base_type;
+                       }
+               }
        }
 
        //
@@ -1211,6 +1260,9 @@ namespace Mono.CSharp
                                                return false;
                                }
 
+                               if (a.IsNested && b.IsNested)
+                                       return IsEqual (a.DeclaringType, b.DeclaringType);
+
                                return true;
                        }
 
@@ -1374,6 +1426,7 @@ namespace Mono.CSharp
                bool IsPartial { get; }
                bool IsComImport { get; }
                bool IsTypeForwarder { get; }
+               bool IsCyclicTypeForwarder { get; }
                int TypeParametersCount { get; }
                TypeParameterSpec[] TypeParameters { get; }
 
@@ -1445,6 +1498,12 @@ namespace Mono.CSharp
                        }
                }
 
+               bool ITypeDefinition.IsCyclicTypeForwarder {
+                       get {
+                               return false;
+                       }
+               }
+
                public override string Name {
                        get {
                                return name;
@@ -1575,6 +1634,12 @@ namespace Mono.CSharp
                        }
                }
 
+               bool ITypeDefinition.IsCyclicTypeForwarder {
+                       get {
+                               return false;
+                       }
+               }
+
                public override string Name {
                        get {
                                throw new NotSupportedException ();
@@ -1872,6 +1937,11 @@ namespace Mono.CSharp
 
                        return ac;
                }
+
+               public override List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller)
+               {
+                       return Element.ResolveMissingDependencies (caller);
+               }
        }
 
        class ReferenceContainer : ElementTypeSpec
@@ -1936,4 +2006,16 @@ namespace Mono.CSharp
                        return pc;
                }
        }
+
+       public class MissingTypeSpecReference
+       {
+               public MissingTypeSpecReference (TypeSpec type, MemberSpec caller)
+               {
+                       Type = type;
+                       Caller = caller;
+               }
+
+               public TypeSpec Type { get; private set; }
+               public MemberSpec Caller { get; private set; }
+       }
 }