A few more tests. Fix bug in ClrTypeSpec2 dealing with nested-in-generic being used as generic type argument.

Author: dmiller

Clojure/Clojure/Lib/ClrTypeSpec2.cs

@@ -498,6 +498,7 @@ void SetGenericArgumentCount(int count)
 
     void MergeNested(ClrTypeSpec nestedSpec)
     {
+        _assemblyName = nestedSpec.AssemblyName;
 
         // Append all nested names to the current type
         if (_nested == null)
@@ -550,7 +551,7 @@ public static ClrTypeSpec Parse(string typeName)
         return res;
     }
 
-    static ClrTypeSpec Parse(string name, ref int p, bool is_recurse, bool allow_aqn, bool allow_mods)
+    static ClrTypeSpec Parse(string name, ref int p, bool is_recurse, bool allow_aqn, bool junk)
     {
         // Invariants:
         //  - On exit p, is updated to pos the current unconsumed character.
@@ -626,22 +627,12 @@ static ClrTypeSpec Parse(string name, ref int p, bool is_recurse, bool allow_aqn
                 switch (name[pos])
                 {
                     case '&':
-                        if (!allow_mods)
-                        {
-                            p = pos;
-                            return data;
-                        }
                         if (data._isByRef)
                             throw new ArgumentException("Can't have a byref of a byref", "typeName");
 
                         data._isByRef = true;
                         break;
                     case '*':
-                        if (!allow_mods)
-                        {
-                            p = pos;
-                            return data;
-                        }
                         if (data._isByRef)
                             throw new ArgumentException("Can't have a pointer to a byref type", "typeName");
                         // take subsequent '*'s too
@@ -654,11 +645,6 @@ static ClrTypeSpec Parse(string name, ref int p, bool is_recurse, bool allow_aqn
                         data.AddModifier(new ClrPointerSpec(pointer_level));
                         break;
                     case ',':
-                        if (!allow_mods)
-                        {
-                            p = pos;
-                            return data;
-                        }
                         if (is_recurse && allow_aqn)
                         {
                             int end = pos;
@@ -737,19 +723,15 @@ static ClrTypeSpec Parse(string name, ref int p, bool is_recurse, bool allow_aqn
                                 pos += 2; // skip "]+" to the start of the nested name
                                 var nested = Parse(name, ref pos, true, false, true);
                                 data.MergeNested(nested);
+                                if (is_recurse)
+                                    // We are going to loop and increment pos, but we haven't yet dealt with the character that ended our nested.
+                                    // Decrement pos so the loop increment will get us back to this place.
+                                    --pos;
                             }
                         }
                         else
                         { //array spec
 
-                            if (!allow_mods)
-                            {
-                                // We have an array spec (a mod) and we are not allowing mods
-                                // Backup to the position of the [ and get us out of here.
-                                p = pos_cache;
-                                return data;
-                            }
-
                             int dimensions = 1;
                             bool bound = false;
                             while (pos < name.Length && name[pos] != ']')

Clojure/Csharp.Tests/TypeNameTests2/TypeNameParsingTests2.cs

@@ -407,12 +407,44 @@ public void NestedGenericWithModifiers_ParsesCorrectly()
     [Test]
     public void NestedGenericAsGenericArg_ParsesCorrectly()
     {
-        var spec = ClrTypeSpec.Parse("A[B+C[D]]");
+        var spec = ClrTypeSpec.Parse("A[B+C[T]]");
         var cmp = TypeSpecComparer.Create("A", 1)
             .WithGenericParams(
                 TypeSpecComparer.Create("B").WithNested(("C", 1))
                     .WithGenericParams(
-                        TypeSpecComparer.Create("D")));
+                        TypeSpecComparer.Create("T")));
+        Assert.That(cmp.SameAs(spec), Is.True);
+
+
+        spec = ClrTypeSpec.Parse("A[B+C[T]+D]");
+        cmp = TypeSpecComparer.Create("A", 1)
+            .WithGenericParams(
+                TypeSpecComparer.Create("B").WithNested(("C", 1), ("D", 0))
+                    .WithGenericParams(
+                        TypeSpecComparer.Create("T")));
+        Assert.That(cmp.SameAs(spec), Is.True);
+
+
+        spec = ClrTypeSpec.Parse("A[B+C[T]]+D");
+        cmp = TypeSpecComparer.Create("A", 1)
+            .WithNested("D")
+            .WithGenericParams(
+                TypeSpecComparer.Create("B").WithNested(("C", 1))
+                    .WithGenericParams(
+                        TypeSpecComparer.Create("T")));
+        Assert.That(cmp.SameAs(spec), Is.True);
+
+
+        spec = ClrTypeSpec.Parse("A[B+C[T],D[U]+E]+F");
+        cmp = TypeSpecComparer.Create("A", 2)
+            .WithNested("F")
+            .WithGenericParams(
+                TypeSpecComparer.Create("B")
+                    .WithNested(("C", 1))
+                    .WithGenericParams(TypeSpecComparer.Create("T")),
+                TypeSpecComparer.Create("D", 1)
+                    .WithNested("E")
+                    .WithGenericParams(TypeSpecComparer.Create("U")));
         Assert.That(cmp.SameAs(spec), Is.True);
     }