[generator] Fix parsing of complex generic types (#729)

Fixes: #728
Context: https://xamarin.github.io/bugzilla-archives/12/12468/bug.html#c1
In order to avoid CS0234 errors, we always write non-intrinsic types
prefixed with `global::`. For example, instead of
System.Collections.Generic.List<Java.Lang.Object>
`generator` emits
global::System.Collections.Generic.List<global::Java.Lang.Object>
To do this, we have to parse a type into its component types so we can
add `global::` to each part. However, our parsing algorithm struggles
with generic types with multiple type arguments.
Thus, this:
System.Collections.Generic.IDictionary<System.Collections.Generic.IList<string>, Kotlin.Pair>
loses the second template parameter, becoming:
global::System.Collections.Generic.IDictionary<global::System.Collections.Generic.IList<string>>
while this:
System.Collections.Generic.IDictionary<System.Collections.Generic.IList<string>, System.Collections.Generic.IList<Kotlin.Pair>>
throws an `ArgumentOutOfRangeException`, which is the cause of #728.
Fix the `ArgumentOutOfRangeException` by introducing a new recursive
parser that better understands generic types.

Author: jpobst

tests/generator-Tests/Unit-Tests/CodeGenerationOptionsTests.cs

@@ -0,0 +1,55 @@
+usingSystem;
+usingMonoDroid.Generation;
+usingNUnit.Framework;
+
+namespacegeneratortests
+{
+[TestFixture]
+publicclassCodeGenerationOptionsTests
+{
+[Test]
+publicvoidGetOutputNameUseGlobal()
+{
+varopt=newCodeGenerationOptions{UseGlobal=true};
+
+Assert.AreEqual(string.Empty,opt.GetOutputName(string.Empty));
+Assert.AreEqual("int",opt.GetOutputName("int"));
+Assert.AreEqual("void",opt.GetOutputName("void"));
+Assert.AreEqual("void",opt.GetOutputName("System.Void"));
+Assert.AreEqual("params int[]",opt.GetOutputName("params int[]"));
+Assert.AreEqual("params global::System.Object[]",opt.GetOutputName("params System.Object[]"));
+Assert.AreEqual("int[][][]",opt.GetOutputName("int[][][]"));
+Assert.AreEqual("global::System.Object[][][]",opt.GetOutputName("System.Object[][][]"));
+
+Assert.AreEqual("global::System.Collections.Generic.List<string[]>",
+opt.GetOutputName("System.Collections.Generic.List<string[]>"));
+
+Assert.AreEqual("global::System.Collections.Generic.Dictionary<string, string>",
+opt.GetOutputName("System.Collections.Generic.Dictionary<string, string>"));
+
+Assert.AreEqual("global::System.Collections.Generic.List<global::System.Collections.Generic.List<string>>",
+opt.GetOutputName("System.Collections.Generic.List<System.Collections.Generic.List<string>>"));
+
+Assert.AreEqual("global::System.Collections.Generic.List<global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.Dictionary<global::System.Object, global::System.Object>>>",
+opt.GetOutputName("System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<System.Object, System.Object>>>"));
+
+Assert.AreEqual("global::System.Collections.Generic.IList<global::Kotlin.Pair>",
+opt.GetOutputName("System.Collections.Generic.IList<Kotlin.Pair>"));
+
+Assert.AreEqual("global::System.Collections.Generic.IDictionary<string, global::System.Collections.Generic.IList<global::Kotlin.Pair>>",
+opt.GetOutputName("System.Collections.Generic.IDictionary<string, System.Collections.Generic.IList<Kotlin.Pair>>"));
+
+Assert.AreEqual("global::System.Collections.Generic.IDictionary<global::System.Collections.Generic.IList<string>, global::Kotlin.Pair>",
+opt.GetOutputName("System.Collections.Generic.IDictionary<System.Collections.Generic.IList<string>, Kotlin.Pair>"));
+
+Assert.AreEqual("global::System.Collections.Generic.IDictionary<global::System.Collections.Generic.IList<string>, global::System.Collections.Generic.IList<global::Kotlin.Pair>>",
+opt.GetOutputName("System.Collections.Generic.IDictionary<System.Collections.Generic.IList<string>, System.Collections.Generic.IList<Kotlin.Pair>>"));
+
+Assert.AreEqual("global::System.Collections.Generic.List<global::System.Collections.Generic.List<string>[]>[]",
+opt.GetOutputName("System.Collections.Generic.List<System.Collections.Generic.List<string>[]>[]"));
+
+Assert.AreEqual("global::System.Collections.Generic.List<global::System.Collections.Generic.List<string>.Enumerator[]>",
+opt.GetOutputName("System.Collections.Generic.List<System.Collections.Generic.List<string>.Enumerator[]>"));
+}
+}
+}

tools/generator/CodeGenerationOptions.cs

@@ -212,42 +212,20 @@ internal IEnumerable<string> GetJniMarshalDelegates ()
 returnjni_marshal_delegates;
 }
 
-publicstringGetOutputName(strings)
+publicstringGetOutputName(stringtype)
 {
-if(s=="System.Void")
+// Handle a few special cases
+if(type=="System.Void")
 return"void";
-if(s.StartsWith("params "))
-return"params "+GetOutputName(s.Substring("params ".Length));
-if(s.StartsWith("global::"))
+if(type.StartsWith("params "))
+return"params "+GetOutputName(type.Substring("params ".Length));
+if(type.StartsWith("global::"))
 Report.LogCodedError(Report.ErrorUnexpectedGlobal);
 if(!UseGlobal)
-returns;
-intidx=s.IndexOf('<');
-if(idx<0){
-if(s.IndexOf('.')<0)
-returns;// hack, to prevent things like global::int
-return"global::"+s;
-}
-intidx2=s.LastIndexOf('>');
-stringsub=s.Substring(idx+1,idx2-idx-1);
-vartypeParams=newList<string>();
-while(true){
-intidx3=sub.IndexOf('<');
-intidx4=sub.IndexOf(',');
-if(idx4<0){
-typeParams.Add(GetOutputName(sub));
-break;
-}elseif(idx3<0||idx4<idx3){// more than one type params.
-typeParams.Add(GetOutputName(sub.Substring(0,idx4)));
-if(idx4+1==sub.Length)
-break;
-sub=sub.Substring(idx4+1).Trim();
-}else{
-typeParams.Add(GetOutputName(sub));
-break;
-}
-}
-returnGetOutputName(s.Substring(0,idx))+'<'+String.Join(", ",typeParams.ToArray())+'>';
+returntype;
+
+// Add "global::" in front of types
+returnParsedType.Parse(type).ToString(UseGlobal);
 }
 
 publicstringGetSafeIdentifier(stringname)

tools/generator/Utilities/ParsedType.cs

@@ -0,0 +1,103 @@
+usingSystem.Collections.Generic;
+usingSystem.Linq;
+
+namespaceMonoDroid.Generation
+{
+// Parses a type string into its type and optionally its generic type arguments
+// ex: Dictionary<string, List<string>>
+// -> Type: Dictionary<{0}>
+// - GenericArguments:
+// - Type: string
+// - Type: List<{0}>
+// - GenericArguments:
+// - Type: string
+// A placeholder "{0}" is added because the type may extend past the generics:
+// ex: "List<string>.Enumerator[]" becomes "List<{0}>.Enumerator[]"
+publicclassParsedType
+{
+publicstringType{get;set;}
+publicList<ParsedType>GenericArguments{get;}=newList<ParsedType>();
+publicboolHasGenerics=>GenericArguments.Count>0;
+
+ParsedType(){}
+
+publicstaticParsedTypeParse(stringtype)
+{
+varless_than=type.IndexOf('<');
+
+// No generics
+if(less_than<0)
+returnnewParsedType{Type=type};
+
+vargreater_than=type.LastIndexOf('>');
+vartype_args=type.Substring(less_than+1,greater_than-less_than-1);
+vartype_string=type.Substring(0,less_than)+"<{0}>"+(greater_than+1<type.Length?type.Substring(greater_than+1):string.Empty);
+
+varparsed_args=ParseTypeList(type_args);
+
+vart=newParsedType{Type=type_string};
+
+foreach(varpinparsed_args)
+t.GenericArguments.Add(Parse(p));
+
+returnt;
+}
+
+publicoverridestringToString()
+{
+returnToString(false);
+}
+
+publicstringToString(booluseGlobal=false)
+{
+vartype=(useGlobal&&Type.IndexOf('.')>=0?"global::":string.Empty)+Type;
+
+if(!HasGenerics)
+returntype;
+
+returntype.Replace("{0}",string.Join(", ",GenericArguments.Select(p =>p.ToString(useGlobal))));
+}
+
+staticList<string>ParseTypeList(stringtype)
+{
+varlist=newList<string>();
+
+// Only one type
+if(type.IndexOf(',')<0){
+list.Add(type);
+returnlist;
+}
+
+// Remove any whitespace
+type=type.Replace(" ","");
+
+varstart=0;
+varcounter=-1;
+vardepth=0;
+
+while(++counter<type.Length){
+if(type[counter]=='<'){
+depth++;
+continue;
+}
+
+if(type[counter]=='>'){
+depth--;
+continue;
+}
+
+// This is a list separator, add the previous type
+if(depth==0&&type[counter]==','){
+list.Add(type.Substring(start,counter-start));
+start=counter+1;
+continue;
+}
+}
+
+// Add the final type
+list.Add(type.Substring(start,counter-start));
+
+returnlist;
+}
+}
+}