[mcs] C#7 throw expression

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

diff --git a/mcs/mcs/typespec.cs b/mcs/mcs/typespec.cs
index 0da8133fbd2c15d75f94f0105d3ee9d750c93de6..53402940dc2dda5959bc5d925cefe29d0701d40c 100644 (file)
--- a/mcs/mcs/typespec.cs
+++ b/mcs/mcs/typespec.cs
@@ -109,7 +109,6 @@ namespace Mono.CSharp
                                        var imported = MemberDefinition as ImportedTypeDefinition;
                                        if (imported != null && Kind != MemberKind.MissingType)
                                                imported.DefineInterfaces (this);
-
                                }
 
                                return ifaces;
@@ -490,17 +489,22 @@ namespace Mono.CSharp
                //
                // Text representation of type used by documentation writer
                //
-               public override string GetSignatureForDocumentation ()
+               public sealed override string GetSignatureForDocumentation ()
+               {
+                       return GetSignatureForDocumentation (false);
+               }
+
+               public virtual string GetSignatureForDocumentation (bool explicitName)
                {
                        StringBuilder sb = new StringBuilder ();
                        if (IsNested) {
-                               sb.Append (DeclaringType.GetSignatureForDocumentation ());
-                       } else {
-                               sb.Append (MemberDefinition.Namespace);
+                               sb.Append (DeclaringType.GetSignatureForDocumentation (explicitName));
+                       } else if (MemberDefinition.Namespace != null) {
+                               sb.Append (explicitName ? MemberDefinition.Namespace.Replace ('.', '#') : MemberDefinition.Namespace);
                        }
 
                        if (sb.Length != 0)
-                               sb.Append (".");
+                               sb.Append (explicitName ? "#" : ".");
 
                        sb.Append (Name);
                        if (Arity > 0) {
@@ -510,7 +514,7 @@ namespace Mono.CSharp
                                        if (i > 0)
                                            sb.Append (",");
 
-                                       sb.Append (TypeArguments[i].GetSignatureForDocumentation ());
+                                               sb.Append (TypeArguments[i].GetSignatureForDocumentation (explicitName));
                                    }
                                    sb.Append ("}");
                                } else {
@@ -522,33 +526,6 @@ namespace Mono.CSharp
                        return sb.ToString ();
                }
 
-               public string GetExplicitNameSignatureForDocumentation ()
-               {
-                       StringBuilder sb = new StringBuilder ();
-                       if (IsNested) {
-                               sb.Append (DeclaringType.GetExplicitNameSignatureForDocumentation ());
-                       } else if (MemberDefinition.Namespace != null) {
-                               sb.Append (MemberDefinition.Namespace.Replace ('.', '#'));
-                       }
-
-                       if (sb.Length != 0)
-                               sb.Append ("#");
-
-                       sb.Append (Name);
-                       if (Arity > 0) {
-                               sb.Append ("{");
-                               for (int i = 0; i < Arity; ++i) {
-                                       if (i > 0)
-                                               sb.Append (",");
-
-                                       sb.Append (TypeArguments[i].GetExplicitNameSignatureForDocumentation ());
-                               }
-                               sb.Append ("}");
-                       }
-
-                       return sb.ToString ();
-               }
-
                public override string GetSignatureForError ()
                {
                        string s;
@@ -569,7 +546,15 @@ namespace Mono.CSharp
 
                public string GetSignatureForErrorIncludingAssemblyName ()
                {
-                       return string.Format ("{0} [{1}]", GetSignatureForError (), MemberDefinition.DeclaringAssembly.FullName);
+                       var imported = MemberDefinition.DeclaringAssembly as ImportedAssemblyDefinition;
+
+                       var location = imported != null ?
+                               System.IO.Path.GetFullPath (imported.Location) :
+                           ((MemberCore)MemberDefinition).Location.NameFullPath;
+
+                       return string.Format ("{0} [{1} -- {2}]", GetSignatureForError (),
+                                                                 MemberDefinition.DeclaringAssembly.FullName,
+                                                                 location);
                }
 
                protected virtual string GetTypeNameSignature ()
@@ -651,6 +636,7 @@ namespace Mono.CSharp
                        case MemberKind.Struct:
                        case MemberKind.Enum:
                        case MemberKind.Void:
+                       case MemberKind.PointerType:
                                return false;
                        case MemberKind.InternalCompilerType:
                                //
@@ -1445,6 +1431,8 @@ namespace Mono.CSharp
                public static readonly InternalType FakeInternalType = new InternalType ("<fake$type>");
                public static readonly InternalType Namespace = new InternalType ("<namespace>");
                public static readonly InternalType ErrorType = new InternalType ("<error>");
+               public static readonly InternalType VarOutType = new InternalType ("var out");
+               public static readonly InternalType ThrowExpr = new InternalType ("throw expression");
 
                readonly string name;
 
@@ -1615,6 +1603,12 @@ namespace Mono.CSharp
 
                public TypeSpec Element { get; private set; }
 
+               public override IList<TypeSpec> Interfaces {
+                       set {
+                               throw new NotSupportedException ();
+                       }
+               }
+
                bool ITypeDefinition.IsComImport {
                        get {
                                return false;
@@ -1647,6 +1641,11 @@ namespace Mono.CSharp
 
                #endregion
 
+               public override void CheckObsoleteness (IMemberContext mc, Location loc)
+               {
+                       Element.CheckObsoleteness (mc, loc);
+               }
+
                public override ObsoleteAttribute GetAttributeObsolete ()
                {
                        return Element.GetAttributeObsolete ();
@@ -1657,9 +1656,9 @@ namespace Mono.CSharp
                        return null;
                }
 
-               public override string GetSignatureForDocumentation ()
+               public override string GetSignatureForDocumentation (bool explicitName)
                {
-                       return Element.GetSignatureForDocumentation () + GetPostfixSignature ();
+                       return Element.GetSignatureForDocumentation (explicitName) + GetPostfixSignature ();
                }
 
                public override string GetSignatureForError ()
@@ -1784,13 +1783,19 @@ namespace Mono.CSharp
                readonly int rank;
                readonly ModuleContainer module;
 
-               private ArrayContainer (ModuleContainer module, TypeSpec element, int rank)
+               ArrayContainer (ModuleContainer module, TypeSpec element, int rank)
                        : base (MemberKind.ArrayType, element, null)
                {
                        this.module = module;
                        this.rank = rank;
                }
 
+               public override IList<TypeSpec> Interfaces {
+                       get {
+                               return BaseType.Interfaces;
+                       }
+               }
+
                public int Rank {
                        get {
                                return rank;
@@ -1892,29 +1897,33 @@ namespace Mono.CSharp
                        return sb.ToString ();
                }
 
-               public override string GetSignatureForDocumentation ()
+               public override string GetSignatureForDocumentation (bool explicitName)
                {
                        StringBuilder sb = new StringBuilder ();
-                       GetElementSignatureForDocumentation (sb);
+                       GetElementSignatureForDocumentation (sb, explicitName);
                        return sb.ToString ();
                }
 
-               void GetElementSignatureForDocumentation (StringBuilder sb)
+               void GetElementSignatureForDocumentation (StringBuilder sb, bool explicitName)
                {
                        var ac = Element as ArrayContainer;
                        if (ac == null)
-                               sb.Append (Element.GetSignatureForDocumentation ());
+                               sb.Append (Element.GetSignatureForDocumentation (explicitName));
                        else
-                               ac.GetElementSignatureForDocumentation (sb);
+                               ac.GetElementSignatureForDocumentation (sb, explicitName);
 
-                       sb.Append ("[");
-                       for (int i = 1; i < rank; i++) {
-                               if (i == 1)
-                                       sb.Append ("0:");
+                       if (explicitName) {
+                               sb.Append (GetPostfixSignature (rank));
+                       } else {
+                               sb.Append ("[");
+                               for (int i = 1; i < rank; i++) {
+                                       if (i == 1)
+                                               sb.Append ("0:");
 
-                               sb.Append (",0:");
+                                       sb.Append (",0:");
+                               }
+                               sb.Append ("]");
                        }
-                       sb.Append ("]");
                }
 
                public static ArrayContainer MakeType (ModuleContainer module, TypeSpec element)
@@ -1929,7 +1938,6 @@ namespace Mono.CSharp
                        if (!module.ArrayTypesCache.TryGetValue (key, out ac)) {
                                ac = new ArrayContainer (module, element, rank);
                                ac.BaseType = module.Compiler.BuiltinTypes.Array;
-                               ac.Interfaces = ac.BaseType.Interfaces;
 
                                module.ArrayTypesCache.Add (key, ac);
                        }
@@ -1945,11 +1953,17 @@ namespace Mono.CSharp
 
        class ReferenceContainer : ElementTypeSpec
        {
-               private ReferenceContainer (TypeSpec element)
+               ReferenceContainer (TypeSpec element)
                        : base (MemberKind.Class, element, null)        // TODO: Kind.Class is most likely wrong
                {
                }
 
+               public override IList<TypeSpec> Interfaces {
+                       get {
+                               return null;
+                       }
+               }
+
                public override MetaType GetMetaInfo ()
                {
                        if (info == null) {
@@ -1980,6 +1994,12 @@ namespace Mono.CSharp
                        state &= ~StateFlags.CLSCompliant_Undetected;
                }
 
+               public override IList<TypeSpec> Interfaces {
+                       get {
+                               return null;
+                       }
+               }
+
                public override MetaType GetMetaInfo ()
                {
                        if (info == null) {