[class-parse] Import parameter names for unresolvable types

Fixes: #920

Context: 69e1b80

`java-source-utils.jar` isn't always able to fully resolve types.
When it is unable to do so, it uses an "alternate encoding":

> In some scenarios, types won't be resolvable.  What should output be?
>
> We don't want to *require* that everything be resolvable -- it's painful, and
> possibly impossible, e.g. w/ internal types -- so instead we should "demark"
> the unresolvable types.
>
> `.params.txt` output will use `.*` as a type prefix, e.g.
>
>         method(.*UnresolvableType foo, int bar);
>
> `docs.xml` will output `L.*UnresolvableType;`.

The problem is that `class-parse --parameter-names=PATH` didn't check
for this "unresolvable type" pattern, so if you had a method which
contained them, e.g. the `target` parameter in:

	<interface jni-signature="Landroidx/core/view/NestedScrollingParent3;" name="NestedScrollingParent3">
	  <method jni-return="V" jni-signature="(L.*View;IIIII[I)V" name="onNestedScroll" return="void">
	    <parameter jni-type="L.*View;" name="target" type=".*View"/>
	    <parameter jni-type="I" name="dxConsumed" type="int"/>
	    <parameter jni-type="I" name="dyConsumed" type="int"/>
	    <parameter jni-type="I" name="dxUnconsumed" type="int"/>
	    <parameter jni-type="I" name="dyUnconsumed" type="int"/>
	    <parameter jni-type="I" name="type" type="int"/>
	    <parameter jni-type="[I" name="consumed" type="int[]"/>

then `class-parse --parameter-names=params.xml lib.jar` wouldn't
try to "loosely match" these parameter types.  Consequently,
parameter names were not imported.

Update `ApiXmlDocScraper.GetParameterNames()` twofold:

 1. Use XLinq instead of computing an XPath expression, and
 2. Loosely match parameter types when `//parameter/@jni-name`
    starts with `L.*`.

This allows us to import parameter names for unresolvable types.

Author: jonpryor

src/Xamarin.Android.Tools.Bytecode/JavaDocumentScraper.cs

@@ -362,37 +362,60 @@ public ApiXmlDocScraper (string apiXmlFile)
 
 		public string[]? GetParameterNames (string package, string type, string method, string[] ptypes, bool isVarArgs)
 		{
-			var methodOrCtor = method == "constructor" ?
-				"constructor[" : $"method[@name='{method}'";
-
-			var pcount = ptypes.Length;
-
-			var xpath = new StringBuilder ();
-
-			xpath.Append ($"/api/package[@name='{package}']/*[self::class or self::interface]/");
-
-			if (method == "constructor")
-				xpath.Append ("constructor[");
-			else
-				xpath.Append ($"method[@name='{method}'");
-
-			xpath.Append ($" and count(parameter)={pcount}");
-
-			if (pcount > 0) {
-				xpath.Append (" and ");
-				xpath.Append (string.Join (" and ", ptypes.Select ((pt, pindex) => $"parameter[{pindex + 1}][@type='{pt}']")));
+			Console.WriteLine ($"# jonp: GetParameterNames: package={package}; type={type}; method={method}");
+			var xtype = xdoc
+				.Elements ("api")
+				.Elements ("package")
+				.Where (p => ((string) p.Attribute ("name")) == package)
+				.Elements ()
+				.Where (t => ((string) t.Attribute ("name")) == type)
+				.FirstOrDefault ();
+			if (xtype == null) {
+				return null;
+			}
+			Console.WriteLine ($"# jonp: found xtype={(string) xtype.Attribute ("name")}");
+
+			var members = method == "constructor"
+				? xtype.Elements ("constructor")
+				: xtype.Elements ("method").Where (m => ((string) m.Attribute ("name")) == method);
+			var pcount  = ptypes.Length;
+			members     = members
+				.Where (m => m.Elements ("parameter").Count () == pcount);
+
+			XElement? member = null;
+			foreach (var m in members) {
+				Console.WriteLine ($"# jonp: looking at member {m}");
+				var found   = true;
+				int i       = 0;
+				foreach (var p in m.Elements ("parameter")) {
+					if (!ParameterTypesMatch (p, ptypes [i++])) {
+						found = false;
+						break;
+					}
+				}
+				if (found) {
+					member = m;
+					break;
+				}
+			}
+			if (member == null)
+				return null;
+			return member.Elements ("parameter")
+				.Select (p => (string) p.Attribute ("name"))
+				.ToArray ();
+
+			bool ParameterTypesMatch (XElement parameter, string ptype)
+			{
+				var xtype = (string) parameter.Attribute ("jni-type");
+				var jtype = (string) parameter.Attribute ("type");
+				Console.WriteLine ($"# jonp: ParameterTypesMatch: xtype={xtype} jtype={jtype} ptype={ptype}");
+				if (!xtype.StartsWith ("L.*", StringComparison.Ordinal)) {
+					return xtype == ptype || jtype == ptype;
+				}
+				jtype = "." + jtype.Substring (".*".Length);
+				Console.WriteLine ($"# jonp: ParameterTypesMatch: \"{ptype}\".EndsWith(\"{jtype}\")? {ptype.EndsWith (jtype, StringComparison.Ordinal)}");
+				return ptype.EndsWith (jtype, StringComparison.Ordinal);
 			}
-
-			xpath.Append ("]");
-
-			var methodElem = xdoc.XPathSelectElement (xpath.ToString ());
-
-			if (methodElem != null)
-				return methodElem.Elements ("parameter")
-					.Select (pe => pe.Attribute ("name")?.Value ?? "")
-					.ToArray ();
-
-			return null;
 		}
 	}
 }