[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)
 		public bool UseShortFileNames { get; set; }
 		public int ProductVersion { get; set; }
 		public bool SupportInterfaceConstants { get; set; }
+		public bool SupportDefaultInterfaceMethods { get; set; }
 		public bool UseShallowReferencedTypes { 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 (var gen in gens) {
-				gen.StripNonBindables ();
+				gen.StripNonBindables (opt);
 				if (gen.IsGeneratable)
 					AddTypeToTable (opt, gen);
 			}

tools/generator/CodeGeneratorOptions.cs

@@ -40,6 +40,7 @@ public CodeGeneratorOptions ()
 		public bool                 OnlyRunApiXmlAdjuster { get; set; }
 		public string               ApiXmlAdjusterOutput { get; set; }
 		public bool                 SupportInterfaceConstants { get; set; }
+		public bool		    SupportDefaultInterfaceMethods { get; set; }
 
 		public static CodeGeneratorOptions Parse (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."));
+				return null;
+			}
+
 			return opts;
 		}
 

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.
 		}
 
-		internal override void WriteMethodBody (Method method, string indent)
+		internal override void WriteMethodBody (Method method, string indent, GenBase type)
 		{
 			writer.WriteLine ("{0}const string __id = \"{1}.{2}\";", indent, method.JavaName, method.JniSignature);
 			foreach (string prep in method.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));
-			} else if (method.IsVirtual && !method.IsAbstract) {
+			} else if ((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));
 		}
 
-		internal override void WriteMethodBody (Method method, string indent)
+		internal override void WriteMethodBody (Method method, string indent, GenBase type)
 		{
 			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 ()
 
 		public void FixupMethodOverrides (CodeGenerationOptions opt)
 		{
-			foreach (var m in Methods.Where (m => !m.IsInterfaceDefaultMethod)) {
+			foreach (var m in Methods.Where (m => !m.IsStatic && !m.IsInterfaceDefaultMethod)) {
 				for (var bt = GetBaseGen (opt); bt != null; bt = bt.GetBaseGen (opt)) {
 					var bm = 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 (var m in Methods.Where (m => m.IsInterfaceDefaultMethod)) {
-				foreach (var bt in GetAllDerivedInterfaces ()) {
-					var bm = bt.Methods.FirstOrDefault (mm => mm.Name == m.Name && ParameterList.Equals (mm.Parameters, m.Parameters));
+			var checkDimOverrideTargets = opt.SupportDefaultInterfaceMethods ? Methods : Methods.Where (m => m.IsInterfaceDefaultMethod);
+
+			// We need to check all the implemented interfaces of all the base types.
+			var allIfaces = new List<InterfaceGen> ();
+
+			for (var gen = this; gen != null; gen = gen.BaseGen)
+				gen.GetAllDerivedInterfaces (allIfaces);
+
+			foreach (var m in checkDimOverrideTargets.Where (m => !m.IsStatic)) {
+				foreach (var bt in allIfaces.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.)
+					var bm = 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)
 		}
 
 		public IEnumerable<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);
 
 		GenBase GetBaseGen (CodeGenerationOptions opt)
 		{
@@ -661,9 +672,12 @@ protected virtual bool OnValidate (CodeGenerationOptions opt, GenericParameterDe
 			}
 			Fields = valid_fields;
 
-			int method_cnt = Methods.Count;
+			// If we can't validate a default interface method it's ok to ignore it and still bind the interface
+			var method_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 (Method m in Methods) {
 				if (m.IsVirtual)
 					HasVirtualMethods = true;
@@ -736,15 +750,16 @@ bool ReturnTypeMatches (Method m, Method mm)
 
 		public bool ShouldGenerateAnnotationAttribute => IsAnnotation;
 
-		public void StripNonBindables ()
+		public void StripNonBindables (CodeGenerationOptions opt)
 		{
-			// 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 (var n in NestedTypes)
-				n.StripNonBindables ();
+				n.StripNonBindables (opt);
 		}
 
 		static readonly HashSet<string> ThrowableRequiresNew = new HashSet<string> (

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

@@ -141,6 +141,8 @@ public IEnumerable<Field> GetGeneratableFields (CodeGenerationOptions options)
 			return Fields.Where (f => !f.NeedsProperty && !(f.DeprecatedComment?.Contains ("constant will be removed") == true));
 		}
 
+		public bool HasDefaultMethods => GetAllMethods ().Any (m => m.IsInterfaceDefaultMethod);
+
 		public bool IsConstSugar {
 			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)
 		public bool IsAbstract { get; set; }
 		public bool IsFinal { get; set; }
 		public bool IsInterfaceDefaultMethod { get; set; }
-		public bool IsInterfaceDefaultMethodOverride { get; set; }
+		public Method OverriddenInterfaceMethod { get; set; }
 		public bool IsReturnEnumified { get; set; }
 		public bool IsStatic { get; set; }
 		public bool IsVirtual { get; set; }
@@ -123,6 +123,9 @@ internal string GetAdapterName (CodeGenerationOptions opt, string adapter)
 			return adapter + AssemblyName;
 		}
 
+		// Connectors for DIM are defined on the interface, not the implementing type
+		public string GetConnectorNameFull (CodeGenerationOptions opt) => ConnectorName + (opt.SupportDefaultInterfaceMethods && IsInterfaceDefaultMethod ? $":{DeclaringType.FullName}, " + (AssemblyName ?? opt.AssemblyName) : string.Empty);
+
 		internal string GetDelegateType ()
 		{
 			var parms = Parameters.DelegateTypeParams;