Initial default interface methods work.

atsushieno · atsushieno · commit f1cd7cc79859 · 2018-06-28T19:50:02.000+09:00
- Added simple test case that contains a DIM method and a DIM-based property.
- CodeGenerator takes SupportDefaultInterfaceMethods property.
- command line option --default-interface-methods is added.
- DIMs in interface generates implementation, not declaration.
- DIM-based properties in interface generates implementation, not declaration.
diff --git a/tools/generator/ClassGen.cs b/tools/generator/ClassGen.cs
@@ -366,24 +366,6 @@ void GenMethods (StreamWriter sw, string indent, CodeGenerationOptions opt)
 			}
 		}
 
-		void GenProperties (StreamWriter sw, string indent, CodeGenerationOptions opt)
-		{
-			foreach (Property prop in Properties) {
-				bool get_virt = prop.Getter.IsVirtual;
-				bool set_virt = prop.Setter == null ? false : prop.Setter.IsVirtual;
-				prop.Getter.IsVirtual = !IsFinal && get_virt;
-				if (prop.Setter != null)
-					prop.Setter.IsVirtual = !IsFinal && set_virt;
-				if (prop.Getter.IsAbstract)
-					prop.GenerateAbstractDeclaration (sw, indent, opt, this);
-				else
-					prop.Generate (this, sw, indent, opt);
-				prop.Getter.IsVirtual = get_virt;
-				if (prop.Setter != null)
-					prop.Setter.IsVirtual = set_virt;
-			}
-		}
-
 		public override void Generate (StreamWriter sw, string indent, CodeGenerationOptions opt, GenerationInfo gen_info)
 		{
 			opt.ContextTypes.Push (this);
@@ -480,7 +462,7 @@ public override void Generate (StreamWriter sw, string indent, CodeGenerationOpt
 
 			GenConstructors (sw, indent + "\t", opt);
 
-			GenProperties (sw, indent + "\t", opt);
+			GenerateImplementedProperties (sw, indent + "\t", IsFinal, opt);
 			GenMethods (sw, indent + "\t", opt);
 
 			if (IsAbstract)
diff --git a/tools/generator/CodeGenerator.cs b/tools/generator/CodeGenerator.cs
@@ -57,6 +57,7 @@ public CodeGeneratorOptions ()
 		public string               MappingReportFile { get; set; }
 		public bool                 OnlyRunApiXmlAdjuster { get; set; }
 		public string               ApiXmlAdjusterOutput { get; set; }
+		public bool                 SupportDefaultInterfaceMethods { get; set; }
 
 		public static CodeGeneratorOptions Parse (string[] args)
 		{
@@ -103,6 +104,9 @@ public static CodeGeneratorOptions Parse (string[] args)
 				{ "sdk-platform|api-level=",
 					"SDK Platform {VERSION}/API level.",
 					v => opts.ApiLevel = v },
+				{ "default-interface-methods",
+					"For internal use.",
+					v => opts.SupportDefaultInterfaceMethods = v != null },
 				{ "preserve-enums",
 					"For internal use.",
 					v => opts.PreserveEnums = v != null },
@@ -242,7 +246,8 @@ static void Run (CodeGeneratorOptions options, DirectoryAssemblyResolver resolve
 				UseGlobal             = options.GlobalTypeNames,
 				IgnoreNonPublicType   = true,
 				UseShortFileNames     = options.UseShortFileNames,
-				ProductVersion        = options.ProductVersion
+				ProductVersion        = options.ProductVersion,
+				SupportDefaultInterfaceMethods = options.SupportDefaultInterfaceMethods,
 			};
 
 			// Load reference libraries
@@ -313,7 +318,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);
 			}
@@ -624,6 +629,7 @@ public      CodeGenerationTarget    CodeGenerationTarget    {
 		public bool UseShortFileNames { get; set; }
 		public IList<GenBase> Gens {get;set;}
 		public int ProductVersion { get; set; }
+		public bool SupportDefaultInterfaceMethods { get; set; }
 
 		public string GetOutputName (string s)
 		{
@@ -1084,7 +1090,8 @@ public void WriteMethod (Method method, TextWriter writer, string indent, CodeGe
 			writer.WriteLine ("{0}[Register (\"{1}\", \"{2}\", \"{3}\"{4})]",
 				indent, method.JavaName, method.JniSignature, method.IsVirtual ? method.ConnectorName : String.Empty, method.AdditionalAttributeString ());
 			WriteMethodCustomAttributes (method, writer, indent);
-			writer.WriteLine ("{0}{1}{2}{3}{4} unsafe {5} {6} ({7})", indent, method.Visibility, static_arg, virt_ov, seal, ret, method.AdjustedName, GenBase.GetSignature (method, opt));
+			string visibility = type.IsInterface ? string.Empty : method.Visibility;
+			writer.WriteLine ("{0}{1}{2}{3}{4} unsafe {5} {6} ({7})", indent, visibility, static_arg, virt_ov, seal, ret, method.AdjustedName, GenBase.GetSignature (method, opt));
 			writer.WriteLine ("{0}{{", indent);
 			WriteMethodBody (method, writer, indent + "\t", opt);
 			writer.WriteLine ("{0}}}", indent);
diff --git a/tools/generator/GenBase.cs b/tools/generator/GenBase.cs
@@ -64,6 +64,10 @@ public string DeprecatedComment {
 		public bool IsGeneratable {
 			get { return support.IsGeneratable; }
 		}
+
+		public virtual bool IsInterface {
+			get { return false; }
+		}
 		
 		public virtual ClassGen BaseGen {
 			get { return null; }
@@ -595,6 +599,24 @@ public List<InterfaceGen> GetAllDerivedInterfaces ()
 			return result;
 		}
 
+		protected void GenerateImplementedProperties (StreamWriter sw, string indent, bool isFinal, CodeGenerationOptions opt)
+		{
+			foreach (Property prop in Properties) {
+				bool get_virt = prop.Getter.IsVirtual;
+				bool set_virt = prop.Setter == null ? false : prop.Setter.IsVirtual;
+				prop.Getter.IsVirtual = !isFinal && get_virt;
+				if (prop.Setter != null)
+					prop.Setter.IsVirtual = !isFinal && set_virt;
+				if (prop.Getter.IsAbstract)
+					prop.GenerateAbstractDeclaration (sw, indent, opt, this);
+				else
+					prop.Generate (this, sw, indent, opt);
+				prop.Getter.IsVirtual = get_virt;
+				if (prop.Setter != null)
+					prop.Setter.IsVirtual = set_virt;
+			}
+		}
+
 		void GetAllDerivedInterfaces (List<InterfaceGen> ifaces)
 		{
 			foreach (ISymbol isym in Interfaces) {
@@ -716,15 +738,16 @@ protected virtual bool OnValidate (CodeGenerationOptions opt, GenericParameterDe
 		
 		bool property_filling;
 
-		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 ();
+			if (!opt.SupportDefaultInterfaceMethods)
+				methods = methods.Where (m => !m.IsInterfaceDefaultMethod).ToList ();
 			nested_types = nested_types.Where (n => !n.IsObfuscated && n.Visibility != "private").ToList ();
 			foreach (var n in nested_types)
-				n.StripNonBindables ();
+				n.StripNonBindables (opt);
 		}
 
 		public virtual void FixupAccessModifiers (CodeGenerationOptions opt)
diff --git a/tools/generator/InterfaceGen.cs b/tools/generator/InterfaceGen.cs
@@ -9,6 +9,7 @@
 
 using Xamarin.Android.Binder;
 using Xamarin.Android.Tools;
+using System.Diagnostics;
 
 namespace MonoDroid.Generation {
 #if HAVE_CECIL
@@ -106,6 +107,10 @@ public bool IsConstSugar {
 			}
 		}
 
+		public override bool IsInterface {
+			get { return true; }
+		}
+
 		public bool IsListener {
 			// If there is a property it cannot generate valid implementor, so reject this at least so far.
 			get { return Name.EndsWith ("Listener") && Properties.Count == 0 && Interfaces.Count == 0; }
@@ -197,11 +202,13 @@ protected override bool OnValidate (CodeGenerationOptions opt, GenericParameterD
 
 		void GenMethods (StreamWriter sw, string indent, CodeGenerationOptions opt)
 		{
-			foreach (Method m in Methods.Where (m => !m.IsStatic)) {
+			foreach (Method m in Methods.Where (m => !m.IsStatic && !m.IsInterfaceDefaultMethod)) {
 				if (m.Name == Name || ContainsProperty (m.Name, true))
 					m.Name = "Invoke" + m.Name;
 				opt.CodeGenerator.WriteMethodDeclaration (m, sw, indent, opt, this, AssemblyQualifiedName + "Invoker");
 			}
+			foreach (Method m in Methods.Where (m => m.IsInterfaceDefaultMethod))
+				opt.CodeGenerator.WriteMethod (m, sw, indent, opt, this, true);
 		}
 
 		void GenExtensionMethods (StreamWriter sw, string indent, CodeGenerationOptions opt)
@@ -214,8 +221,9 @@ void GenExtensionMethods (StreamWriter sw, string indent, CodeGenerationOptions
 
 		void GenProperties (StreamWriter sw, string indent, CodeGenerationOptions opt)
 		{
-			foreach (Property prop in Properties.Where (p => !p.Getter.IsStatic))
+			foreach (Property prop in Properties.Where (p => !p.Getter.IsStatic && !p.Getter.IsInterfaceDefaultMethod))
 				prop.GenerateDeclaration (sw, indent, opt, this, AssemblyQualifiedName + "Invoker");
+			base.GenerateImplementedProperties (sw, indent, false, opt);
 		}
 
 		void GenerateInvoker (StreamWriter sw, string indent, CodeGenerationOptions opt)
@@ -256,14 +264,14 @@ void GenerateInvoker (StreamWriter sw, string indent, CodeGenerationOptions opt)
 			sw.WriteLine ();
 
 			HashSet<string> members = new HashSet<string> ();
-			GenerateInvoker (sw, Properties.Where (p => !p.Getter.IsStatic), indent + "\t", opt, members);
-			GenerateInvoker (sw, Methods.Where (m => !m.IsStatic), indent + "\t", opt, members);
+			GenerateInvoker (sw, Properties.Where (p => !p.Getter.IsStatic && !p.Getter.IsInterfaceDefaultMethod), indent + "\t", opt, members);
+			GenerateInvoker (sw, Methods.Where (m => !m.IsStatic && !m.IsInterfaceDefaultMethod), indent + "\t", opt, members);
 			if (FullName == "Java.Lang.ICharSequence")
 				GenCharSequenceEnumerator (sw, indent + "\t", opt);
 
 			foreach (InterfaceGen iface in GetAllDerivedInterfaces ()) {
-				GenerateInvoker (sw, iface.Properties.Where (p => !p.Getter.IsStatic), indent + "\t", opt, members);
-				GenerateInvoker (sw, iface.Methods.Where (m => !m.IsStatic && !IsCovariantMethod (m) && !(iface.FullName.StartsWith ("Java.Lang.ICharSequence") && m.Name.EndsWith ("Formatted"))), indent + "\t", opt, members);
+				GenerateInvoker (sw, iface.Properties.Where (p => !p.Getter.IsStatic && !p.Getter.IsInterfaceDefaultMethod), indent + "\t", opt, members);
+				GenerateInvoker (sw, iface.Methods.Where (m => !m.IsStatic && !m.IsInterfaceDefaultMethod && !IsCovariantMethod (m) && !(iface.FullName.StartsWith ("Java.Lang.ICharSequence") && m.Name.EndsWith ("Formatted"))), indent + "\t", opt, members);
 				if (iface.FullName == "Java.Lang.ICharSequence")
 					GenCharSequenceEnumerator (sw, indent + "\t", opt);
 			}
diff --git a/tools/generator/Property.cs b/tools/generator/Property.cs
@@ -264,7 +264,7 @@ public void Generate (GenBase gen, StreamWriter sw, string indent, CodeGeneratio
 			opt.CodeGenerator.WriteMethodIdField (Getter, sw, indent, opt);
 			if (Setter != null)
 				opt.CodeGenerator.WriteMethodIdField (Setter, sw, indent, opt);
-			string visibility = Getter.IsAbstract && Getter.RetVal.IsGeneric ? "protected" : (Setter ?? Getter).Visibility;
+			string visibility = gen.IsInterface ? string.Empty : Getter.IsAbstract && Getter.RetVal.IsGeneric ? "protected" : (Setter ?? Getter).Visibility;
 			// Unlike [Register], mcs does not allow applying [Obsolete] on property accessors, so we can apply them only under limited condition...
 			if (Getter.Deprecated != null && (Setter == null || Setter.Deprecated != null))
 				sw.WriteLine ("{0}[Obsolete (@\"{1}\")]", indent, Getter.Deprecated.Replace ("\"", "\"\"").Trim () + (Setter != null && Setter.Deprecated != Getter.Deprecated ? " " + Setter.Deprecated.Replace ("\"", "\"\"").Trim () : null));
diff --git a/tools/generator/Tests/Integration-Tests/DefaultInterfaceMethods.cs b/tools/generator/Tests/Integration-Tests/DefaultInterfaceMethods.cs
@@ -0,0 +1,28 @@
+﻿using System;
+using System.IO;
+using NUnit.Framework;
+using Xamarin.Android.Binder;
+
+namespace generatortests
+{
+	[TestFixture]
+	public class DefaultInterfaceMethods : BaseGeneratorTest
+	{
+		[Test]
+		public void GeneratedOK ()
+		{
+			Options.SupportDefaultInterfaceMethods = true;
+			RunAllTargets (
+					outputRelativePath: "DefaultInterfaceMethods",
+					apiDescriptionFile: "expected.ji/DefaultInterfaceMethods/DefaultInterfaceMethods.xml",
+					expectedRelativePath: "DefaultInterfaceMethods",
+					additionalSupportPaths: null);
+		}
+
+		void RunAllTargets (string outputRelativePath, string apiDescriptionFile, string expectedRelativePath, string [] additionalSupportPaths)
+		{
+			Run (CodeGenerationTarget.JavaInterop1, Path.Combine ("out.ji", outputRelativePath), apiDescriptionFile, Path.Combine ("expected.ji", expectedRelativePath), additionalSupportPaths);
+		}
+	}
+}
+
diff --git a/tools/generator/Tests/expected.ji/DefaultInterfaceMethods/DefaultInterfaceMethods.xml b/tools/generator/Tests/expected.ji/DefaultInterfaceMethods/DefaultInterfaceMethods.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<api>
+	<package name="java.lang">
+		<class abstract="false" deprecated="not deprecated" final="false" name="Object" static="false" visibility="public">
+		</class>
+	</package>
+	<package name="xamarin.test">
+		<interface abstract="true" deprecated="not deprecated" final="false" name="TheInterface" static="false" visibility="public">
+			<method abstract="false" deprecated="not deprecated" final="false" name="foo" native="false" return="int" static="false" synchronized="false" visibility="public">
+            </method>
+			<method abstract="false" deprecated="not deprecated" final="false" name="getBar" native="false" return="int" static="false" synchronized="false" visibility="public">
+			</method>
+		</interface>
+	</package>
+</api>
diff --git a/tools/generator/Tests/expected.ji/DefaultInterfaceMethods/Xamarin.Test.ITheInterface.cs b/tools/generator/Tests/expected.ji/DefaultInterfaceMethods/Xamarin.Test.ITheInterface.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using Android.Runtime;
+
+namespace Xamarin.Test {
+
+	// Metadata.xml XPath interface reference: path="/api/package[@name='xamarin.test']/interface[@name='TheInterface']"
+	[Register ("xamarin/test/TheInterface", "", "Xamarin.Test.ITheInterfaceInvoker")]
+	public partial interface ITheInterface : IJavaObject {
+
+		static Delegate cb_getBar;
+#pragma warning disable 0169
+		static Delegate GetGetBarHandler ()
+		{
+			if (cb_getBar == null)
+				cb_getBar = JNINativeWrapper.CreateDelegate ((Func<IntPtr, IntPtr, int>) n_GetBar);
+			return cb_getBar;
+		}
+
+		static int n_GetBar (IntPtr jnienv, IntPtr native__this)
+		{
+			global::Xamarin.Test.TheInterface __this = global::Java.Lang.Object.GetObject<global::Xamarin.Test.TheInterface> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
+			return __this.Bar;
+		}
+#pragma warning restore 0169
+
+		public virtual unsafe int Bar {
+			// Metadata.xml XPath method reference: path="/api/package[@name='xamarin.test']/class[@name='TheInterface']/method[@name='getBar' and count(parameter)=0]"
+			[Register ("getBar", "()I", "GetGetBarHandler")]
+			get {
+				const string __id = "getBar.()I";
+				try {
+					var __rm = _members.InstanceMethods.InvokeVirtualInt32Method (__id, this, null);
+					return __rm;
+				} finally {
+				}
+			}
+		}
+
+		static Delegate cb_foo;
+#pragma warning disable 0169
+		static Delegate GetFooHandler ()
+		{
+			if (cb_foo == null)
+				cb_foo = JNINativeWrapper.CreateDelegate ((Func<IntPtr, IntPtr, int>) n_Foo);
+			return cb_foo;
+		}
+
+		static int n_Foo (IntPtr jnienv, IntPtr native__this)
+		{
+			global::Xamarin.Test.TheInterface __this = global::Java.Lang.Object.GetObject<global::Xamarin.Test.TheInterface> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
+			return __this.Foo ();
+		}
+#pragma warning restore 0169
+
+		// Metadata.xml XPath method reference: path="/api/package[@name='xamarin.test']/class[@name='TheInterface']/method[@name='foo' and count(parameter)=0]"
+		[Register ("foo", "()I", "GetFooHandler")]
+		public virtual unsafe int Foo ()
+		{
+			const string __id = "foo.()I";
+			try {
+				var __rm = _members.InstanceMethods.InvokeVirtualInt32Method (__id, this, null);
+				return __rm;
+			} finally {
+			}
+		}
+	}
+
+	[global::Android.Runtime.Register ("xamarin/test/TheInterface", DoNotGenerateAcw=true)]
+	internal class ITheInterfaceInvoker : global::Java.Lang.Object, ITheInterface {
+
+		static IntPtr java_class_ref = JNIEnv.FindClass ("xamarin/test/TheInterface");
+
+		protected override IntPtr ThresholdClass {
+			get { return class_ref; }
+		}
+
+		protected override global::System.Type ThresholdType {
+			get { return typeof (ITheInterfaceInvoker); }
+		}
+
+		IntPtr class_ref;
+
+		public static ITheInterface GetObject (IntPtr handle, JniHandleOwnership transfer)
+		{
+			return global::Java.Lang.Object.GetObject<ITheInterface> (handle, transfer);
+		}
+
+		static IntPtr Validate (IntPtr handle)
+		{
+			if (!JNIEnv.IsInstanceOf (handle, java_class_ref))
+				throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.",
+							JNIEnv.GetClassNameFromInstance (handle), "xamarin.test.TheInterface"));
+			return handle;
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			if (this.class_ref != IntPtr.Zero)
+				JNIEnv.DeleteGlobalRef (this.class_ref);
+			this.class_ref = IntPtr.Zero;
+			base.Dispose (disposing);
+		}
+
+		public ITheInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer)
+		{
+			IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle);
+			this.class_ref = JNIEnv.NewGlobalRef (local_ref);
+			JNIEnv.DeleteLocalRef (local_ref);
+		}
+	}
+
+}
diff --git a/tools/generator/Tests/generator-Tests.csproj b/tools/generator/Tests/generator-Tests.csproj
