[Java.Interop.Tools.JavaCallableWrappers] JavaCallableMethodClassifier (#998)

Context: dotnet/android#7123
Context: fb94d59
Instead of having `JavaCallableWrapperGenerator` care about and
collect marshal methods override information, introduce a new
`JavaCallableMethodClassifier` type, and use that as the integration
point:
public abstract partial class JavaCallableMethodClassifier {
public abstract bool ShouldBeDynamicallyRegistered TypeDefinition topType,
MethodDefinition registeredMethod,
MethodDefinition implementedMethod,
CustomAttribute registerAttribute
);
}
An instance of `JavaCallableMethodClassifier` can now be provided to
the `JavaCallableWrapperGenerator` constructor. If provided, then
`ShouldBeDynamicallyRegistered()` will be used to control which
methods are added to `__md_methods` and `Runtime.register()`.
If a type `JavaCallableWrapperGenerator` is processing doesn't have
any dynamically registered methods, then the code to register them
is no longer generated.

Author: grendello

src/Java.Interop.NamingCustomAttributes/Android.Runtime/RegisterAttribute.cs

@@ -1,5 +1,7 @@
 usingSystem;
 
+usingMono.Cecil;
+
 namespaceAndroid.Runtime{
 
 [AttributeUsage(AttributeTargets.Class|AttributeTargets.Constructor|AttributeTargets.Field|AttributeTargets.Interface|AttributeTargets.Method|AttributeTargets.Property)]
@@ -23,6 +25,21 @@ public RegisterAttribute (string name, string signature, string connector)
 this.connector=connector;
 this.signature=signature;
 }
+#if HAVE_CECIL
+publicRegisterAttribute(stringname,CustomAttributeoriginAttribute)
+:this(name)
+{
+OriginAttribute=originAttribute;
+}
+
+publicRegisterAttribute(stringname,stringsignature,stringconnector,CustomAttributeoriginAttribute)
+:this(name,signature,connector)
+{
+OriginAttribute=originAttribute;
+}
+
+publicCustomAttributeOriginAttribute{get;}
+#endif // HAVE_CECIL
 
 publicstringConnector{
 get{returnconnector;}

src/Java.Interop.Tools.JavaCallableWrappers/Java.Interop.Tools.JavaCallableWrappers/JavaCallableWrapperGenerator.cs

@@ -25,40 +25,9 @@ public enum JavaPeerStyle {
 JavaInterop1,
 }
 
-publicclassOverriddenMethodDescriptor
+publicabstractclassJavaCallableMethodClassifier
 {
-staticreadonlychar[]methodDescSplitChars=newchar[]{':'};
-
-publicstringJavaPackageName{get;}
-publicstringNativeName{get;}
-publicstringJniSignature{get;}
-publicstringConnector{get;}
-publicstringManagedTypeName{get;}
-publicstringOriginalDescString{get;}
-
-publicOverriddenMethodDescriptor(stringjavaPackageName,stringmethodDescription,stringfallbackManagedTypeName)
-{
-OriginalDescString=methodDescription;
-JavaPackageName=javaPackageName;
-string[]parts=methodDescription.Split(methodDescSplitChars,4);
-
-if(parts.Length<2){
-thrownewInvalidOperationException($"Unexpected format for method description. Expected at least 2 parts, got {parts.Length} from: '{methodDescription}'");
-}
-
-NativeName=parts[0];
-JniSignature=parts[1];
-if(parts.Length>2){
-Connector=parts[2];
-if(parts.Length>3){
-ManagedTypeName=TypeDefinitionRocks.CecilTypeNameToReflectionTypeName(parts[3]);
-}
-}
-
-if(String.IsNullOrEmpty(ManagedTypeName)){
-ManagedTypeName=fallbackManagedTypeName;
-}
-}
+publicabstractboolShouldBeDynamicallyRegistered(TypeDefinitiontopType,MethodDefinitionregisteredMethod,MethodDefinitionimplementedMethod,CustomAttributeregisterAttribute);
 }
 
 publicclassJavaCallableWrapperGenerator{
@@ -95,36 +64,47 @@ public string GetJavaAccess ()
 List<Signature>methods=newList<Signature>();
 List<Signature>ctors=newList<Signature>();
 List<JavaCallableWrapperGenerator>children;
-List<OverriddenMethodDescriptor>overriddenMethodDescriptors;
+
 readonlyIMetadataResolvercache;
+readonlyJavaCallableMethodClassifiermethodClassifier;
 
 [Obsolete("Use the TypeDefinitionCache overload for better performance.")]
 publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log)
-:this(type,null,log,resolver:null)
+:this(type,log,resolver:null,methodClassifier:null)
 {}
 
 publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log,TypeDefinitionCachecache)
-:this(type,log,(IMetadataResolver)cache)
+:this(type,log,(IMetadataResolver)cache,methodClassifier:null)
+{}
+
+publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log,TypeDefinitionCachecache,JavaCallableMethodClassifiermethodClassifier)
+:this(type,log,(IMetadataResolver)cache,methodClassifier)
 {
 }
 
 publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log,IMetadataResolverresolver)
-:this(type,null,log,resolver)
+:this(type,log,resolver,methodClassifier:null)
+{}
+
+publicJavaCallableWrapperGenerator(TypeDefinitiontype,Action<string,object[]>log,IMetadataResolverresolver,JavaCallableMethodClassifiermethodClassifier)
+:this(type,null,log,resolver,methodClassifier)
 {
 if(type.HasNestedTypes){
 children=newList<JavaCallableWrapperGenerator>();
 AddNestedTypes(type);
 }
 }
 
-publicIList<OverriddenMethodDescriptor>OverriddenMethodDescriptors=>overriddenMethodDescriptors;
 publicstringApplicationJavaClass{get;set;}
 publicJavaPeerStyleCodeGenerationTarget{get;set;}
 
 publicboolGenerateOnCreateOverrides{get;set;}
 
 publicboolHasExport{get;privateset;}
 
+// If there are no methods, we need to generate "empty" registration because of backward compatibility
+publicboolHasDynamicallyRegisteredMethods=>methods.Count==0||methods.Any((Signaturesig)=>sig.IsDynamicallyRegistered);
+
 /// <summary>
 /// The Java source code to be included in Instrumentation.onCreate
 ///
@@ -152,8 +132,9 @@ void AddNestedTypes (TypeDefinition type)
 HasExport|=children.Any(t =>t.HasExport);
 }
 
-JavaCallableWrapperGenerator(TypeDefinitiontype,stringouterType,Action<string,object[]>log,IMetadataResolverresolver)
+JavaCallableWrapperGenerator(TypeDefinitiontype,stringouterType,Action<string,object[]>log,IMetadataResolverresolver,JavaCallableMethodClassifiermethodClassifier=null)
 {
+this.methodClassifier=methodClassifier;
 this.type=type;
 this.log=log;
 this.cache=resolver??newTypeDefinitionCache();
@@ -366,12 +347,13 @@ internal static RegisterAttribute ToRegisterAttribute (CustomAttribute attr)
 // attr.Resolve ();
 RegisterAttributer=null;
 if(attr.ConstructorArguments.Count==1)
-r=newRegisterAttribute((string)attr.ConstructorArguments[0].Value);
+r=newRegisterAttribute((string)attr.ConstructorArguments[0].Value,attr);
 elseif(attr.ConstructorArguments.Count==3)
 r=newRegisterAttribute(
 (string)attr.ConstructorArguments[0].Value,
 (string)attr.ConstructorArguments[1].Value,
-(string)attr.ConstructorArguments[2].Value);
+(string)attr.ConstructorArguments[2].Value,
+attr);
 if(r!=null){
 varv=attr.Properties.FirstOrDefault(p =>p.Name=="DoNotGenerateAcw");
 r.DoNotGenerateAcw=v.Name==null?false:(bool)v.Argument.Value;
@@ -384,7 +366,7 @@ internal static RegisterAttribute RegisterFromJniTypeSignatureAttribute (CustomA
 // attr.Resolve ();
 RegisterAttributer=null;
 if(attr.ConstructorArguments.Count==1)
-r=newRegisterAttribute((string)attr.ConstructorArguments[0].Value);
+r=newRegisterAttribute((string)attr.ConstructorArguments[0].Value,attr);
 if(r!=null){
 varv=attr.Properties.FirstOrDefault(p =>p.Name=="GenerateJavaPeer");
 if(v.Name==null){
@@ -403,7 +385,8 @@ internal static RegisterAttribute RegisterFromJniMethodSignatureAttribute (Custo
 if(attr.ConstructorArguments.Count==2)
 r=newRegisterAttribute((string)attr.ConstructorArguments[0].Value,
 (string)attr.ConstructorArguments[1].Value,
-"");
+"",
+attr);
 returnr;
 }
 
@@ -467,7 +450,8 @@ void AddMethod (MethodDefinition registeredMethod, MethodDefinition implementedM
 if(attr.Name.Contains("-impl")||(attr.Name.Length>7&&attr.Name[attr.Name.Length-8]=='-'))
 Diagnostic.Error(4217,LookupSource(implementedMethod),Localization.Resources.JavaCallableWrappers_XA4217,attr.Name);
 
-varmsig=newSignature(implementedMethod,attr);
+boolshouldBeDynamicallyRegistered=methodClassifier?.ShouldBeDynamicallyRegistered(type,registeredMethod,implementedMethod,attr.OriginAttribute)??true;
+varmsig=newSignature(implementedMethod,attr,shouldBeDynamicallyRegistered);
 if(!registeredMethod.IsConstructor&&!methods.Any(m =>m.Name==msig.Name&&m.Params==msig.Params))
 methods.Add(msig);
 }
@@ -542,21 +526,38 @@ public void Generate (TextWriter writer)
 
 GenerateHeader(writer);
 
-writer.WriteLine("/** @hide */");
-writer.WriteLine("\tpublic static final String __md_methods;");
-if(children!=null){
-foreach(variinEnumerable.Range(1,children.Count))
-writer.WriteLine("\tstatic final String __md_{0}_methods;",i);
+boolneedCtor=false;
+if(HasDynamicallyRegisteredMethods){
+needCtor=true;
+writer.WriteLine("/** @hide */");
+writer.WriteLine("\tpublic static final String __md_methods;");
 }
-writer.WriteLine("\tstatic {");
-GenerateRegisterType(writer,this,"__md_methods");
+
 if(children!=null){
-for(inti=0;i<children.Count;++i){
-stringmethods=string.Format("__md_{0}_methods",i+1);
-GenerateRegisterType(writer,children[i],methods);
+for(inti=0;i<children.Count;i++){
+if(!children[i].HasDynamicallyRegisteredMethods){
+continue;
+}
+needCtor=true;
+writer.WriteLine("\tstatic final String __md_{0}_methods;",i+1);
 }
 }
-writer.WriteLine("\t}");
+
+if(needCtor){
+writer.WriteLine("\tstatic {");
+
+if(HasDynamicallyRegisteredMethods){
+GenerateRegisterType(writer,this,"__md_methods");
+}
+
+if(children!=null){
+for(inti=0;i<children.Count;++i){
+stringmethods=string.Format("__md_{0}_methods",i+1);
+GenerateRegisterType(writer,children[i],methods);
+}
+}
+writer.WriteLine("\t}");
+}
 
 GenerateBody(writer);
 
@@ -710,16 +711,18 @@ void GenerateBody (TextWriter sw)
 
 voidGenerateRegisterType(TextWritersw,JavaCallableWrapperGeneratorself,stringfield)
 {
-if(overriddenMethodDescriptors==null){
-overriddenMethodDescriptors=newList<OverriddenMethodDescriptor>();
+if(!self.HasDynamicallyRegisteredMethods){
+return;
 }
 
 sw.WriteLine("\t\t{0} = ",field);
 stringmanagedTypeName=self.type.GetPartialAssemblyQualifiedName(cache);
 stringjavaTypeName=$"{package}.{name}";
+
 foreach(Signaturemethodinself.methods){
-sw.WriteLine("\t\t\t\"{0}\\n\" +",method.Method);
-overriddenMethodDescriptors.Add(newOverriddenMethodDescriptor(javaTypeName,method.Method,managedTypeName));
+if(method.IsDynamicallyRegistered){
+sw.WriteLine("\t\t\t\"{0}\\n\" +",method.Method);
+}
 }
 sw.WriteLine("\t\t\t\"\";");
 if(CannotRegisterInStaticConstructor(self.type))
@@ -772,12 +775,13 @@ bool CannotRegisterInStaticConstructor (TypeDefinition type)
 
 classSignature{
 
-publicSignature(MethodDefinitionmethod,RegisterAttributeregister):this(method,register,null,null){}
+publicSignature(MethodDefinitionmethod,RegisterAttributeregister,boolshouldBeDynamicallyRegistered=true):this(method,register,null,null,shouldBeDynamicallyRegistered){}
 
-publicSignature(MethodDefinitionmethod,RegisterAttributeregister,stringmanagedParameters,stringouterType)
+publicSignature(MethodDefinitionmethod,RegisterAttributeregister,stringmanagedParameters,stringouterType,boolshouldBeDynamicallyRegistered=true)
 :this(register.Name,register.Signature,register.Connector,managedParameters,outerType,null)
 {
 Annotations=JavaCallableWrapperGenerator.GetAnnotationsString("\t",method.CustomAttributes);
+IsDynamicallyRegistered=shouldBeDynamicallyRegistered;
 }
 
 publicSignature(MethodDefinitionmethod,ExportAttributeexport,IMetadataResolvercache)
@@ -880,6 +884,7 @@ public string ThrowsDeclaration {
 publicreadonlystringMethod;
 publicreadonlyboolIsExport;
 publicreadonlyboolIsStatic;
+publicreadonlyboolIsDynamicallyRegistered=true;
 publicreadonlystring[]ThrownTypeNames;
 publicreadonlystringAnnotations;
 }