[generator] Support default interface methods. (#459)

Fixes: #25
Context: #341
Java 8 supports [interface default methods][0]:
public interface HelloJava8 {
public void a ();
public default int getFoo () {
return 8;
}
public default void setFoo (int newValue) {
throw new UnsupportedOperationException();
}
}
With C#8, C# also supports [default interface members][1].
Add a new `generator --lang-features=default-interface-methods` flag
which takes advantage of C#8 default interface members to bind Java 8
default interface methods:
// C# binding of HelloJava8
public partial interface IHelloJava8 : IJavaObject, IJavaPeerable {
static new readonly JniPeerMembers _members = new JniPeerMembers ("HelloJava8", typeof (IHelloJava8));
void A();
virtual unsafe int Foo {
[Regsiter ("getFoo", "()I", "…")]
get {
return _members.InstanceMethods.InvokeVirtualInt32Method ("getFoo.()I", this, null);
}
[Regsiter ("setFoo", "(I)V", "…")]
set {
JniArgumentValue* __args = stackalloc JniArgumentValue [1];
__args [0] = new JniArgumentValue (value);
return _members.InstanceMethods.InvokeVirtualVoidMethod ("setFoo.(I)V", this, __args);
}
}
}
C#8 Default Interface Members cannot be used with legacy
`generator --codegen-target=XamarinAndroid`, as they require the
`IJavaPeerable` infrastructure in order to work.
Connector Methods are emitted within the interface binding, and not
within the corresponding `*Invoker` type.
If a Java default interface method is "invalid", we just skip binding
the method instead of invalidating the entire interface, just as we
do with classes and non-`abstract` methods.
Finally, the default interface method implementation uses `virtual`
dispatch, *not* non-`virtual` dispatch, in order to support Java-side
versioning. For example, imagine `exampele.jar` v1:
// Java
public interface Fooable {
default void foo() {
System.out.println ("Fooable.foo");
}
}
public class Example implements Fooable {
}
In v1, `Example` does *not* contain an `Example.foo()` method, though
`foo()` can be invoked on it, because of `Fooable.foo()`:
Fooable value = new Example();
value.foo(); // Invokes Fooable.foo()
In v2, `Example` overrides `Fooable.foo`:
public class Example implements Fooable {
public void foo() {
System.out.println ("Example.foo");
}
}
If our binding used non-`virtual` dispatch for `IFooable.Foo()`, and
bound `example.jar` v1, then if we updated `example.jar` to v2
*without* producing a new binding -- and why should a new binding
be required? -- then we would continue invoking `Fooable.foo()` when
we *should* be invoking `Example.foo()`. Use of `virtual` dispatch
thus ensures we support Java-side versioning.
[0]: https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html
[1]: https://github.com/dotnet/csharplang/blob/f7952cdddf85316a4beec493a0ecc14fcb3241c8/proposals/csharp-8.0/default-interface-methods.md

Author: jpobst

src/Java.Interop/Java.Interop/JniPeerMembers.JniInstanceMethods_Invoke.tt

@@ -44,7 +44,7 @@ namespace Java.Interop {
  JniPeerMembers.AssertSelf (self);
 
  var declaringType = DeclaringType;
- if (Members.ShouldUseVirtualDispatch (self, declaringType)) {
+ if (Members.UsesVirtualDispatch (self, declaringType)) {
  var m = GetMethodInfo (encodedMember);
  <#= returnType.ReturnType != "void" ? "return " : "" #>JniEnvironment.InstanceMethods.Call<#= returnType.JniCallType #>Method (self.PeerReference, m, parameters);
  <#= returnType.ReturnType == "void" ? "return;" : "" #>

tools/generator/CodeGenerationOptions.cs

@@ -48,6 +48,7 @@ internal CodeGenerator CreateCodeGenerator (TextWriter writer)
 publicboolUseShortFileNames{get;set;}
 publicintProductVersion{get;set;}
 publicboolSupportInterfaceConstants{get;set;}
+publicboolSupportDefaultInterfaceMethods{get;set;}
 publicboolUseShallowReferencedTypes{get;set;}
 
 bool?buildingCoreAssembly;

tools/generator/CodeGenerator.cs

@@ -66,6 +66,7 @@ static void Run (CodeGeneratorOptions options, DirectoryAssemblyResolver resolve
 UseShortFileNames=options.UseShortFileNames,
 ProductVersion=options.ProductVersion,
 SupportInterfaceConstants=options.SupportInterfaceConstants,
+SupportDefaultInterfaceMethods=options.SupportDefaultInterfaceMethods,
 };
 
 // Load reference libraries
@@ -143,7 +144,7 @@ static void Run (CodeGeneratorOptions options, DirectoryAssemblyResolver resolve
 // disable interface default methods here, especially before validation.
 gens=gens.Where(g =>!g.IsObfuscated&&g.Visibility!="private").ToList();
 foreach(vargeningens){
-gen.StripNonBindables();
+gen.StripNonBindables(opt);
 if(gen.IsGeneratable)
 AddTypeToTable(opt,gen);
 }

tools/generator/CodeGeneratorOptions.cs

@@ -40,6 +40,7 @@ public CodeGeneratorOptions ()
 publicboolOnlyRunApiXmlAdjuster{get;set;}
 publicstringApiXmlAdjusterOutput{get;set;}
 publicboolSupportInterfaceConstants{get;set;}
+publicboolSupportDefaultInterfaceMethods{get;set;}
 
 publicstaticCodeGeneratorOptionsParse(string[]args)
 {
@@ -87,8 +88,11 @@ public static CodeGeneratorOptions Parse (string[] args)
 "SDK Platform {VERSION}/API level.",
  v =>opts.ApiLevel=v},
 {"lang-features=",
-"For internal use. (Flags: interface-constants)",
- v =>opts.SupportInterfaceConstants=v?.Contains("interface-constants")==true},
+"For internal use. (Flags: interface-constants,default-interface-methods)",
+ v =>{
+opts.SupportInterfaceConstants=v?.Contains("interface-constants")==true;
+opts.SupportDefaultInterfaceMethods=v?.Contains("default-interface-methods")==true;
+}},
 {"preserve-enums",
 "For internal use.",
  v =>opts.PreserveEnums=v!=null},
@@ -157,6 +161,11 @@ public static CodeGeneratorOptions Parse (string[] args)
 
 opts.ApiDescriptionFile=apis[0];
 
+if(opts.SupportDefaultInterfaceMethods&&opts.CodeGenerationTarget==CodeGenerationTarget.XamarinAndroid){
+Console.Error.WriteLine(Report.Format(true,Report.ErrorInvalidArgument,"lang-features=default-interface-methods is not compatible with codegen-target=xamarinandroid."));
+returnnull;
+}
+
 returnopts;
 }
 

tools/generator/Java.Interop.Tools.Generator.CodeGeneration/CodeGenerator.cs

@@ -134,7 +134,7 @@ internal override void WriteMethodIdField (Method method, string indent)
 // No method id_ field required; it's now an `id` constant in the binding.
 }
 
-internaloverridevoidWriteMethodBody(Methodmethod,stringindent)
+internaloverridevoidWriteMethodBody(Methodmethod,stringindent,GenBasetype)
 {
 writer.WriteLine("{0}const string __id = \"{1}.{2}\";",indent,method.JavaName,method.JniSignature);
 foreach(stringprepinmethod.Parameters.GetCallPrep(opt))
@@ -159,7 +159,7 @@ internal override void WriteMethodBody (Method method, string indent)
 writer.WriteLine("_members.InstanceMethods.InvokeNonvirtual{0}Method (__id, this{1});",
 invokeType,
 method.Parameters.GetCallArgs(opt,invoker:false));
-}elseif(method.IsVirtual&&!method.IsAbstract){
+}elseif((method.IsVirtual&&!method.IsAbstract)||method.IsInterfaceDefaultMethod){
 writer.WriteLine("_members.InstanceMethods.InvokeVirtual{0}Method (__id, this{1});",
 invokeType,
 method.Parameters.GetCallArgs(opt,invoker:false));

tools/generator/Java.Interop.Tools.Generator.CodeGeneration/JavaInteropCodeGenerator.cs

@@ -123,7 +123,7 @@ void GenerateJNICall (Method method, string indent, string call, bool declare_re
 writer.WriteLine("{0}return {1};",indent,method.RetVal.FromNative(opt,call,true));
 }
 
-internaloverridevoidWriteMethodBody(Methodmethod,stringindent)
+internaloverridevoidWriteMethodBody(Methodmethod,stringindent,GenBasetype)
 {
 writer.WriteLine("{0}if ({1} == IntPtr.Zero)",indent,method.EscapedIdName);
 writer.WriteLine("{0}\t{1} = JNIEnv.Get{2}MethodID (class_ref, \"{3}\", \"{4}\");",indent,method.EscapedIdName,method.IsStatic?"Static":String.Empty,method.JavaName,method.JniSignature);

tools/generator/Java.Interop.Tools.Generator.CodeGeneration/XamarinAndroidCodeGenerator.cs

@@ -290,7 +290,7 @@ public virtual void FixupExplicitImplementation ()
 
 publicvoidFixupMethodOverrides(CodeGenerationOptionsopt)
 {
-foreach(varminMethods.Where(m =>!m.IsInterfaceDefaultMethod)){
+foreach(varminMethods.Where(m =>!m.IsStatic&&!m.IsInterfaceDefaultMethod)){
 for(varbt=GetBaseGen(opt);bt!=null;bt=bt.GetBaseGen(opt)){
 varbm=bt.Methods.FirstOrDefault(mm =>mm.Name==m.Name&&mm.Visibility==m.Visibility&&ParameterList.Equals(mm.Parameters,m.Parameters));
 if(bm!=null&&bm.RetVal.FullName==m.RetVal.FullName){// if return type is different, it could be still "new", not "override".
@@ -301,11 +301,22 @@ public void FixupMethodOverrides (CodeGenerationOptions opt)
 }
 
 // Interface default methods can be overriden. We want to process them differently.
-foreach(varminMethods.Where(m =>m.IsInterfaceDefaultMethod)){
-foreach(varbtinGetAllDerivedInterfaces()){
-varbm=bt.Methods.FirstOrDefault(mm =>mm.Name==m.Name&&ParameterList.Equals(mm.Parameters,m.Parameters));
+varcheckDimOverrideTargets=opt.SupportDefaultInterfaceMethods?Methods:Methods.Where(m =>m.IsInterfaceDefaultMethod);
+
+// We need to check all the implemented interfaces of all the base types.
+varallIfaces=newList<InterfaceGen>();
+
+for(vargen=this;gen!=null;gen=gen.BaseGen)
+gen.GetAllDerivedInterfaces(allIfaces);
+
+foreach(varmincheckDimOverrideTargets.Where(m =>!m.IsStatic)){
+foreach(varbtinallIfaces.Distinct()){
+// We mark a method as an override if (1) it is a DIM, or (2) if the base method is DIM
+// (i.e. we don't mark as override if a class method "implements" normal iface method.)
+varbm=bt.Methods.FirstOrDefault(mm =>(m.IsInterfaceDefaultMethod||!mm.IsAbstract)&&mm.Name==m.Name&&ParameterList.Equals(mm.Parameters,m.Parameters));
+
 if(bm!=null){
-m.IsInterfaceDefaultMethodOverride=true;
+m.OverriddenInterfaceMethod=bm;
 break;
 }
 }
@@ -411,7 +422,7 @@ void visit (ISymbol isym)
 }
 
 publicIEnumerable<Method>GetAllMethods()=>
-Methods.Concat(Properties.Select(p =>p.Getter)).Concat(Properties.Select(p =>p.Setter).Where(m =>m!=null));
+Methods.Concat(Properties.Select(p =>p.Getter)).Concat(Properties.Select(p =>p.Setter)).Where(m =>m!=null);
 
 GenBaseGetBaseGen(CodeGenerationOptionsopt)
 {
@@ -661,9 +672,12 @@ protected virtual bool OnValidate (CodeGenerationOptions opt, GenericParameterDe
 }
 Fields=valid_fields;
 
-intmethod_cnt=Methods.Count;
+// If we can't validate a default interface method it's ok to ignore it and still bind the interface
+varmethod_cnt=Methods.Where(m =>!m.IsInterfaceDefaultMethod).Count();
+
 Methods=Methods.Where(m =>ValidateMethod(opt,m,context)).ToList();
-MethodValidationFailed=method_cnt!=Methods.Count;
+MethodValidationFailed=method_cnt!=Methods.Where(m =>!m.IsInterfaceDefaultMethod).Count();
+
 foreach(MethodminMethods){
 if(m.IsVirtual)
 HasVirtualMethods=true;
@@ -736,15 +750,16 @@ bool ReturnTypeMatches (Method m, Method mm)
 
 publicboolShouldGenerateAnnotationAttribute=>IsAnnotation;
 
-publicvoidStripNonBindables()
+publicvoidStripNonBindables(CodeGenerationOptionsopt)
 {
-// As of now, if we generate bindings for interface default methods, that means users will
-// have to "implement" those methods because they are declared and you have to implement
-// any declared methods in C#. That is going to be problematic a lot.
-Methods=Methods.Where(m =>!m.IsInterfaceDefaultMethod).ToList();
+// Strip out default interface methods if not desired
+if(!opt.SupportDefaultInterfaceMethods)
+Methods=Methods.Where(m =>!m.IsInterfaceDefaultMethod).ToList();
+
 NestedTypes=NestedTypes.Where(n =>!n.IsObfuscated&&n.Visibility!="private").ToList();
+
 foreach(varninNestedTypes)
-n.StripNonBindables();
+n.StripNonBindables(opt);
 }
 
 staticreadonlyHashSet<string>ThrowableRequiresNew=newHashSet<string>(

tools/generator/Java.Interop.Tools.Generator.ObjectModel/GenBase.cs

@@ -141,6 +141,8 @@ public IEnumerable<Field> GetGeneratableFields (CodeGenerationOptions options)
 returnFields.Where(f =>!f.NeedsProperty&&!(f.DeprecatedComment?.Contains("constant will be removed")==true));
 }
 
+publicboolHasDefaultMethods=>GetAllMethods().Any(m =>m.IsInterfaceDefaultMethod);
+
 publicboolIsConstSugar{
 get{
 if(Methods.Count>0||Properties.Count>0)

tools/generator/Java.Interop.Tools.Generator.ObjectModel/InterfaceGen.cs

@@ -20,7 +20,7 @@ public Method (GenBase declaringType) : base (declaringType)
 publicboolIsAbstract{get;set;}
 publicboolIsFinal{get;set;}
 publicboolIsInterfaceDefaultMethod{get;set;}
-publicboolIsInterfaceDefaultMethodOverride{get;set;}
+publicMethodOverriddenInterfaceMethod{get;set;}
 publicboolIsReturnEnumified{get;set;}
 publicboolIsStatic{get;set;}
 publicboolIsVirtual{get;set;}
@@ -123,6 +123,9 @@ internal string GetAdapterName (CodeGenerationOptions opt, string adapter)
 returnadapter+AssemblyName;
 }
 
+// Connectors for DIM are defined on the interface, not the implementing type
+publicstringGetConnectorNameFull(CodeGenerationOptionsopt)=>ConnectorName+(opt.SupportDefaultInterfaceMethods&&IsInterfaceDefaultMethod?$":{DeclaringType.FullName}, "+(AssemblyName??opt.AssemblyName):string.Empty);
+
 internalstringGetDelegateType()
 {
 varparms=Parameters.DelegateTypeParams;