diff --git a/test-app/.gitignore b/test-app/.gitignore index d9360d209..6d116d89e 100644 --- a/test-app/.gitignore +++ b/test-app/.gitignore @@ -25,4 +25,5 @@ NativeScriptActivity.java NativeScriptApplication.java # named extend() classes the static binding generator writes for the specs app/src/main/java/com/tns/tests/defaults/ +app/src/main/java/com/tns/tests/extras/ **/com/tns/gen \ No newline at end of file diff --git a/test-app/app/src/main/assets/app/mainpage.js b/test-app/app/src/main/assets/app/mainpage.js index fc3012617..642ae0d0b 100644 --- a/test-app/app/src/main/assets/app/mainpage.js +++ b/test-app/app/src/main/assets/app/mainpage.js @@ -41,6 +41,7 @@ require("./tests/testWorkerNestedConsole"); require("./tests/testMessaging"); require("./tests/testInterfaceDefaultMethods"); require("./tests/testInterfaceDefaultMethodOverrides"); +require("./tests/testInterfaceExtraInterfaces"); require("./tests/testInterfaceStaticMethods"); require("./tests/testMetadata"); require("./tests/testAsserts"); diff --git a/test-app/app/src/main/assets/app/tests/interfaceExtraInterfacesWorker.js b/test-app/app/src/main/assets/app/tests/interfaceExtraInterfacesWorker.js new file mode 100644 index 000000000..6e30a3ed7 --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/interfaceExtraInterfacesWorker.js @@ -0,0 +1,21 @@ +// Entry for testInterfaceExtraInterfaces: an interface extend with an extra interface, made and +// constructed in a worker's runtime. +var X = com.tns.tests.interfaces.extras; +var F = X.ExtrasFixtures; +var result = {}; + +try { + var B = X.WorkerBase; + var C = B.extend({ + interfaces: [X.Extra], + base: function () { return "worker base"; }, + extra: function () { return "worker extra"; } + }); + var instance = new C(); + result.className = String(F.className(instance)); + result.isExtra = F.isInstance(instance, "com.tns.tests.interfaces.extras.Extra"); + result.extra = String(F.call(instance, "com.tns.tests.interfaces.extras.Extra", "extra")); +} catch (e) { + result.error = String(e && e.message || e); +} +postMessage(result); diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js new file mode 100644 index 000000000..c6ab41025 --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -0,0 +1,438 @@ +// An extend() of a Java interface that lists more interfaces in `interfaces`. Every spec uses +// a base interface no other spec touches: the class generated for an interface without extra +// interfaces is shared by every runtime of the process under one name. The call sites reach +// the app's interfaces through `X`, so the static binding generator does not prebuild their +// classes; the specs at the end name platform interfaces in full on purpose. +describe("Interface extends with extra interfaces", function () { + var sdk = android.os.Build.VERSION.SDK_INT; + var X = com.tns.tests.interfaces.extras; + var F = X.ExtrasFixtures; + var Extra = X.Extra; + var PKG = "com.tns.tests.interfaces.extras."; + var EXTRA = PKG + "Extra"; + var OTHER = PKG + "OtherExtra"; + + function sharedClassName(baseName) { + return "com.tns.gen." + baseName.replace(/\$/g, "_"); + } + + function expectCallSiteClass(instance, baseName) { + var className = String(F.className(instance)); + expect(className.indexOf(sharedClassName(baseName) + "_")).toBe(0); + } + + it("implement the base and the extra interfaces in Java", function () { + var B = X.MainBase; + var runs = 0; + var C = B.extend({ + interfaces: [Extra, java.lang.Runnable], + base: function () { return "js base"; }, + extra: function () { return "js extra"; }, + run: function () { runs++; } + }); + var instance = new C(); + + expectCallSiteClass(instance, PKG + "MainBase"); + expect(F.isInstance(instance, PKG + "MainBase")).toBe(true); + expect(F.isInstance(instance, EXTRA)).toBe(true); + expect(F.isInstance(instance, "java.lang.Runnable")).toBe(true); + expect(String(F.interfaceNames(instance))).toBe(EXTRA + ",com.tns.tests.interfaces.extras.MainBase,java.lang.Runnable"); + expect(String(F.call(instance, PKG + "MainBase", "base"))).toBe("js base"); + expect(String(F.call(instance, EXTRA, "extra"))).toBe("js extra"); + expect(F.isRuntimeGenerated(instance)).toBe(true); + + // Typed parameters are not checked before the call, so only an instance of the type + // may be passed. + if (F.isInstance(instance, EXTRA)) { + expect(String(F.runExtra(instance))).toBe("js extra"); + } + if (F.isInstance(instance, "java.lang.Runnable")) { + new java.lang.Thread(instance).run(); + expect(runs).toBe(1); + } + }); + + it("get a class per extend call, apart from the base's shared class", function () { + var B = X.TwoSitesBase; + var WithExtra = B.extend({ + interfaces: [Extra], + base: function () { return "with extra"; }, + extra: function () { return "extra of the first"; } + }); + var WithOther = B.extend({ + interfaces: [X.OtherExtra], + base: function () { return "with other"; }, + other: function () { return "other of the second"; } + }); + var Without = B.extend({ + base: function () { return "without"; } + }); + var withExtra = new WithExtra(); + var withOther = new WithOther(); + var without = new Without(); + + expect(WithExtra).not.toBe(WithOther); + expectCallSiteClass(withExtra, PKG + "TwoSitesBase"); + expectCallSiteClass(withOther, PKG + "TwoSitesBase"); + expect(String(F.className(withExtra))).not.toBe(String(F.className(withOther))); + expect(String(F.className(without))).toBe(sharedClassName(PKG + "TwoSitesBase")); + + expect(F.isInstance(withExtra, EXTRA)).toBe(true); + expect(F.isInstance(withExtra, OTHER)).toBe(false); + expect(F.isInstance(withOther, OTHER)).toBe(true); + expect(F.isInstance(withOther, EXTRA)).toBe(false); + expect(F.isInstance(without, EXTRA)).toBe(false); + + expect(String(F.call(withExtra, PKG + "TwoSitesBase", "base"))).toBe("with extra"); + expect(String(F.call(withOther, PKG + "TwoSitesBase", "base"))).toBe("with other"); + expect(String(F.call(withOther, OTHER, "other"))).toBe("other of the second"); + expect(String(F.call(without, PKG + "TwoSitesBase", "base"))).toBe("without"); + }); + + it("leave the base's shared class alone when it was created first", function () { + var B = X.PlainFirstBase; + var plain = new B({ base: function () { return "plain"; } }); + var C = B.extend({ + interfaces: [Extra], + base: function () { return "extras"; }, + extra: function () { return "js extra"; } + }); + var withExtras = new C(); + + expect(String(F.className(plain))).toBe(sharedClassName(PKG + "PlainFirstBase")); + expect(F.isInstance(plain, EXTRA)).toBe(false); + expectCallSiteClass(withExtras, PKG + "PlainFirstBase"); + expect(F.isInstance(withExtras, EXTRA)).toBe(true); + expect(String(F.call(withExtras, EXTRA, "extra"))).toBe("js extra"); + }); + + it("leave the base's shared class alone when they are created first", function () { + var B = X.ExtrasFirstBase; + var C = B.extend({ + interfaces: [Extra], + base: function () { return "extras"; }, + extra: function () { return "js extra"; } + }); + var withExtras = new C(); + var plain = new B({ base: function () { return "plain"; } }); + + expectCallSiteClass(withExtras, PKG + "ExtrasFirstBase"); + expect(F.isInstance(withExtras, EXTRA)).toBe(true); + expect(String(F.className(plain))).toBe(sharedClassName(PKG + "ExtrasFirstBase")); + expect(F.isInstance(plain, EXTRA)).toBe(false); + expect(String(F.call(plain, PKG + "ExtrasFirstBase", "base"))).toBe("plain"); + }); + + it("call the JS implementations of default methods of the base and of the extras", function () { + if (sdk < 24) { + return; + } + var B = X.DefaultsBase; + var removes = 0; + var Overriding = B.extend({ + interfaces: [Extra, java.util.Iterator], + base: function () { return "b"; }, + extra: function () { return "e"; }, + hasNext: function () { return false; }, + next: function () { return null; }, + baseDefault: function () { return "js baseDefault"; }, + extraDefault: function () { return "js extraDefault"; }, + remove: function () { removes++; } + }); + var NotOverriding = B.extend({ + interfaces: [Extra, java.util.Iterator], + base: function () { return "b"; }, + extra: function () { return "e"; }, + hasNext: function () { return false; }, + next: function () { return null; } + }); + var overriding = new Overriding(); + var notOverriding = new NotOverriding(); + + expectCallSiteClass(overriding, PKG + "DefaultsBase"); + expect(String(F.className(overriding)).indexOf("-defaults")).toBe(-1); + expect(String(F.call(overriding, PKG + "DefaultsBase", "baseDefault"))).toBe("js baseDefault"); + expect(String(F.call(overriding, EXTRA, "extraDefault"))).toBe("js extraDefault"); + F.call(overriding, "java.util.Iterator", "remove"); + expect(removes).toBe(1); + expect(String(F.call(notOverriding, "java.util.Iterator", "remove"))).toBe("java.lang.UnsupportedOperationException"); + if (F.areDefaultsDesugared()) { + return; + } + expect(String(F.call(notOverriding, PKG + "DefaultsBase", "baseDefault"))).toBe("java"); + expect(String(F.call(notOverriding, EXTRA, "extraDefault"))).toBe("java"); + }); + + it("call the JS implementation of a default method the base and an extra both declare", function () { + if (sdk < 24) { + return; + } + var B = X.ConflictBase; + var C = B.extend({ + interfaces: [X.ConflictExtra], + base: function () { return "b"; }, + shared: function () { return "js shared"; } + }); + var instance = new C(); + + expect(F.isInstance(instance, PKG + "ConflictExtra")).toBe(true); + expect(String(F.call(instance, PKG + "ConflictBase", "shared"))).toBe("js shared"); + expect(String(F.call(instance, PKG + "ConflictExtra", "shared"))).toBe("js shared"); + }); + + it("implement an interface listed twice, or the base listed again, once", function () { + var B = X.DuplicateBase; + var C = B.extend({ + interfaces: [B, Extra, Extra], + base: function () { return "b"; }, + extra: function () { return "e"; } + }); + var instance = new C(); + + expectCallSiteClass(instance, PKG + "DuplicateBase"); + expect(String(F.interfaceNames(instance))).toBe("com.tns.tests.interfaces.extras.DuplicateBase," + EXTRA); + expect(String(F.call(instance, EXTRA, "extra"))).toBe("e"); + }); + + it("keep a class listed as an extra interface out of the implemented interfaces", function () { + var B = X.NotAnInterfaceBase; + var C = B.extend({ + interfaces: [X.AbstractExtra], + base: function () { return "b"; }, + abstractExtra: function () { return "a"; } + }); + var instance = new C(); + + expect(String(F.interfaceNames(instance))).toBe("com.tns.tests.interfaces.extras.NotAnInterfaceBase"); + expect(F.isInstance(instance, PKG + "AbstractExtra")).toBe(false); + expect(String(F.call(instance, PKG + "NotAnInterfaceBase", "base"))).toBe("b"); + }); + + it("implement the extra interfaces of a nested base interface", function () { + var B = X.Bases.Nested; + var C = B.extend({ + interfaces: [Extra], + base: function () { return "nested"; }, + extra: function () { return "nested extra"; } + }); + var instance = new C(); + + expectCallSiteClass(instance, PKG + "Bases$Nested"); + expect(F.isInstance(instance, EXTRA)).toBe(true); + expect(String(F.call(instance, PKG + "Bases$Nested", "base"))).toBe("nested"); + }); + + it("implement the extra interfaces of a named extend", function () { + var B = X.NamedBase; + var C = B.extend("com.tns.tests.extras.NamedRuntimeExtras", { + interfaces: [Extra], + base: function () { return "named base"; }, + extra: function () { return "named extra"; }, + extraDefault: function () { return "named extraDefault"; } + }); + var instance = new C(); + + expect(String(F.className(instance))).toBe("com.tns.tests.extras.NamedRuntimeExtras"); + expect(F.isRuntimeGenerated(instance)).toBe(true); + expect(F.isInstance(instance, EXTRA)).toBe(true); + expect(String(F.call(instance, EXTRA, "extra"))).toBe("named extra"); + if (sdk >= 24) { + expect(String(F.call(instance, EXTRA, "extraDefault"))).toBe("named extraDefault"); + } + }); + + it("implement the extra interfaces of a TypeScript class decorated with Interfaces", function () { + var TSBase = X.TypeScriptBase; + var Decorated = (function (_super) { + __extends(Decorated, _super); + function Decorated() { + return _super.apply(this, arguments) || this; + } + Decorated.prototype.base = function () { return "ts base"; }; + Decorated.prototype.extra = function () { return "ts extra"; }; + Decorated = __decorate([ + Interfaces([X.Extra]) + ], Decorated); + return Decorated; + }(TSBase)); + var instance = new Decorated(); + + expectCallSiteClass(instance, PKG + "TypeScriptBase"); + expect(F.isInstance(instance, EXTRA)).toBe(true); + expect(String(F.call(instance, EXTRA, "extra"))).toBe("ts extra"); + expect(String(F.call(instance, PKG + "TypeScriptBase", "base"))).toBe("ts base"); + }); + + // Java calls value() through the method of the type it holds, Number value() or + // Integer value(): each needs the JS implementation. + function expectValueThroughEitherType(instance, baseName) { + expect(String(F.call(instance, baseName, "value"))).toBe("41"); + expect(String(F.call(instance, PKG + "Covariant$IntegerExtra", "value"))).toBe("41"); + } + + it("call the JS implementation of a default method declared with different return types", function () { + var B = X.Covariant.NumberBase; + var C = B.extend({ + interfaces: [X.Covariant.IntegerExtra], + value: function () { return new java.lang.Integer(41); } + }); + var instance = new C(); + + expect(F.isInstance(instance, PKG + "Covariant$IntegerExtra")).toBe(true); + expectValueThroughEitherType(instance, PKG + "Covariant$NumberBase"); + }); + + it("call the JS implementation of a default method declared with different return types in a named extend", function () { + var B = X.Covariant.NamedNumberBase; + var C = B.extend("com.tns.tests.extras.NamedCovariantExtras", { + interfaces: [X.Covariant.IntegerExtra], + value: function () { return new java.lang.Integer(41); } + }); + var instance = new C(); + + expect(F.isInstance(instance, PKG + "Covariant$IntegerExtra")).toBe(true); + expectValueThroughEitherType(instance, PKG + "Covariant$NamedNumberBase"); + }); + + it("call the JS implementation of an abstract method declared with different return types", function () { + var B = X.Covariant.AbstractNumberBase; + var C = B.extend({ + interfaces: [X.Covariant.AbstractIntegerExtra], + amount: function () { return new java.lang.Integer(42); } + }); + var instance = new C(); + + expect(String(F.call(instance, PKG + "Covariant$AbstractNumberBase", "amount"))).toBe("42"); + expect(String(F.call(instance, PKG + "Covariant$AbstractIntegerExtra", "amount"))).toBe("42"); + }); + + it("call the JS implementation of a class extend's abstract method its interfaces declare with different return types", function () { + var O = java.lang.Object; + var C = O.extend({ + interfaces: [X.Covariant.AbstractNumberBase, X.Covariant.AbstractIntegerExtra], + amount: function () { return new java.lang.Integer(43); } + }); + var instance = new C(); + + expect(String(F.call(instance, PKG + "Covariant$AbstractNumberBase", "amount"))).toBe("43"); + expect(String(F.call(instance, PKG + "Covariant$AbstractIntegerExtra", "amount"))).toBe("43"); + }); + + it("leave a class listed as an extra interface out of the default methods to call", function () { + var B = X.ClassListed.Base; + var C = B.extend("com.tns.tests.extras.NamedClassListedExtras", { + interfaces: [X.ClassListed.Implementor], + value: function () { return "js value"; } + }); + var instance = new C(); + + expect(F.isInstance(instance, PKG + "ClassListed$Implementor")).toBe(false); + expect(String(F.call(instance, PKG + "ClassListed$Base", "value"))).toBe("js value"); + }); + + it("cache their dex under the class's own name", function () { + var B = X.CacheBase; + var C = B.extend({ + interfaces: [Extra], + base: function () { return "b"; }, + extra: function () { return "e"; } + }); + var className = String(F.className(new C())); + + // The dex is looked up by this name on the next launch. + expect(F.cachedDexFiles(className + "-").length).toBe(1); + }); + + it("leave the interfaces of new Interface({...}) out of the shared class", function () { + var B = X.NewWithInterfacesBase; + var instance = new B({ + interfaces: [Extra], + base: function () { return "b"; }, + extra: function () { return "e"; } + }); + + expect(String(F.className(instance))).toBe(sharedClassName(PKG + "NewWithInterfacesBase")); + expect(F.isInstance(instance, EXTRA)).toBe(false); + expect(String(F.call(instance, PKG + "NewWithInterfacesBase", "base"))).toBe("b"); + }); + + it("implement the extra interfaces in a worker", function (done) { + var DEADLINE_MS = 20000; + var finished = false; + var worker = new Worker("./interfaceExtraInterfacesWorker.js"); + + function finish(result) { + if (finished) { + return; + } + finished = true; + clearTimeout(timer); + worker.terminate(); + + expect(result.error).toBeUndefined(); + expect(String(result.className).indexOf(sharedClassName(PKG + "WorkerBase") + "_")).toBe(0); + expect(result.isExtra).toBe(true); + expect(result.extra).toBe("worker extra"); + + // The last use of WorkerBase: the shared class still serves new WorkerBase({...}). + var plain = new X.WorkerBase({ base: function () { return "main"; } }); + expect(String(F.className(plain))).toBe(sharedClassName(PKG + "WorkerBase")); + expect(F.isInstance(plain, EXTRA)).toBe(false); + expect(String(F.call(plain, PKG + "WorkerBase", "base"))).toBe("main"); + done(); + } + + var timer = setTimeout(function () { + finish({ error: "the worker did not report within " + DEADLINE_MS + "ms" }); + }, DEADLINE_MS); + worker.onmessage = function (msg) { + finish(msg.data); + }; + worker.onerror = function (e) { + finish({ error: "worker error: " + (e && e.message) }); + }; + }, 30000); + + // Named in full, so the static binding generator prebuilds their classes. The + // java.util.function interfaces need API 24. + it("are prebuilt under the call-site class name, apart from the base's shared class", function () { + if (sdk < 24) { + return; + } + var Prebuilt = java.util.function.LongSupplier.extend({ + interfaces: [java.util.function.IntSupplier], + getAsLong: function () { return 41; }, + getAsInt: function () { return 42; } + }); + var plain = new java.util.function.LongSupplier({ + getAsLong: function () { return 43; } + }); + var prebuilt = new Prebuilt(); + + expectCallSiteClass(prebuilt, "java.util.function.LongSupplier"); + expect(F.isRuntimeGenerated(prebuilt)).toBe(false); + expect(F.isInstance(prebuilt, "java.util.function.IntSupplier")).toBe(true); + expect(String(F.call(prebuilt, "java.util.function.IntSupplier", "getAsInt"))).toBe("42"); + + expect(String(F.className(plain))).toBe("com.tns.gen.java.util.function.LongSupplier"); + expect(F.isInstance(plain, "java.util.function.IntSupplier")).toBe(false); + expect(String(F.call(plain, "java.util.function.LongSupplier", "getAsLong"))).toBe("43"); + }); + + it("are prebuilt with the extra interfaces of a named extend", function () { + if (sdk < 24) { + return; + } + var Named = java.util.function.DoubleSupplier.extend("com.tns.tests.extras.NamedPrebuiltExtras", { + interfaces: [java.util.function.BooleanSupplier], + getAsDouble: function () { return 1.5; }, + getAsBoolean: function () { return true; } + }); + var instance = new Named(); + + expect(String(F.className(instance))).toBe("com.tns.tests.extras.NamedPrebuiltExtras"); + expect(F.isRuntimeGenerated(instance)).toBe(false); + expect(F.isInstance(instance, "java.util.function.BooleanSupplier")).toBe(true); + expect(String(F.call(instance, "java.util.function.BooleanSupplier", "getAsBoolean"))).toBe("true"); + }); +}); diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/AbstractExtra.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/AbstractExtra.java new file mode 100644 index 000000000..83a3f524a --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/AbstractExtra.java @@ -0,0 +1,6 @@ +package com.tns.tests.interfaces.extras; + +// Listed in an extend's `interfaces` although it is a class. +public abstract class AbstractExtra { + public abstract String abstractExtra(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Bases.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Bases.java new file mode 100644 index 000000000..9e4819a75 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Bases.java @@ -0,0 +1,10 @@ +package com.tns.tests.interfaces.extras; + +public final class Bases { + private Bases() { + } + + public interface Nested { + String base(); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/CacheBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/CacheBase.java new file mode 100644 index 000000000..5663f8aff --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/CacheBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface CacheBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ClassListed.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ClassListed.java new file mode 100644 index 000000000..84559130c --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ClassListed.java @@ -0,0 +1,20 @@ +package com.tns.tests.interfaces.extras; + +// A class listed in an extend's `interfaces` that implements the base's default method. +public final class ClassListed { + private ClassListed() { + } + + public interface Base { + default String value() { + return "java"; + } + } + + public abstract static class Implementor implements Base { + @Override + public String value() { + return "class"; + } + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictBase.java new file mode 100644 index 000000000..1178346f2 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictBase.java @@ -0,0 +1,10 @@ +package com.tns.tests.interfaces.extras; + +// shared() conflicts with ConflictExtra's: a class implementing both has to override it. +public interface ConflictBase { + String base(); + + default String shared() { + return "base"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictExtra.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictExtra.java new file mode 100644 index 000000000..7e4ecda7e --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictExtra.java @@ -0,0 +1,7 @@ +package com.tns.tests.interfaces.extras; + +public interface ConflictExtra { + default String shared() { + return "extra"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Covariant.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Covariant.java new file mode 100644 index 000000000..a1714d663 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Covariant.java @@ -0,0 +1,34 @@ +package com.tns.tests.interfaces.extras; + +// Unrelated interfaces declaring the same method with different return types: a class +// implementing two of them is called through a different method descriptor for each. +public final class Covariant { + private Covariant() { + } + + public interface NumberBase { + default Number value() { + return 1; + } + } + + public interface NamedNumberBase { + default Number value() { + return 1; + } + } + + public interface IntegerExtra { + default Integer value() { + return 2; + } + } + + public interface AbstractNumberBase { + Number amount(); + } + + public interface AbstractIntegerExtra { + Integer amount(); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/DefaultsBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/DefaultsBase.java new file mode 100644 index 000000000..c69083c50 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/DefaultsBase.java @@ -0,0 +1,9 @@ +package com.tns.tests.interfaces.extras; + +public interface DefaultsBase { + String base(); + + default String baseDefault() { + return "java"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/DuplicateBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/DuplicateBase.java new file mode 100644 index 000000000..dfae6eb0e --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/DuplicateBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface DuplicateBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Extra.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Extra.java new file mode 100644 index 000000000..de3533567 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/Extra.java @@ -0,0 +1,9 @@ +package com.tns.tests.interfaces.extras; + +public interface Extra { + String extra(); + + default String extraDefault() { + return "java"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFirstBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFirstBase.java new file mode 100644 index 000000000..62834f757 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFirstBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface ExtrasFirstBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFixtures.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFixtures.java new file mode 100644 index 000000000..4417d3e03 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFixtures.java @@ -0,0 +1,101 @@ +package com.tns.tests.interfaces.extras; + +import android.content.Context; + +import java.io.File; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +// Java callers for testInterfaceExtraInterfaces.js. Every method but runExtra takes Object, so +// an instance that lacks an interface reaches Java and is reported instead of crossing JNI +// as an argument of a type it does not have. +public final class ExtrasFixtures { + private ExtrasFixtures() { + } + + public static String className(Object instance) { + return instance.getClass().getName(); + } + + public static boolean isInstance(Object instance, String interfaceName) throws ClassNotFoundException { + return Class.forName(interfaceName).isInstance(instance); + } + + // The interfaces the instance's class declares, sorted, without the runtime's own. + public static String interfaceNames(Object instance) { + List names = new ArrayList(); + for (Class iface : instance.getClass().getInterfaces()) { + if (!iface.getName().startsWith("com.tns.NativeScript")) { + names.add(iface.getName()); + } + } + Collections.sort(names); + StringBuilder joined = new StringBuilder(); + for (String name : names) { + if (joined.length() > 0) { + joined.append(','); + } + joined.append(name); + } + return joined.toString(); + } + + // Calls the interface's no-argument method through the interface, as a Java caller holding + // the instance as that type would. + public static String call(Object instance, String interfaceName, String methodName) { + try { + Class iface = Class.forName(interfaceName); + if (!iface.isInstance(instance)) { + return "not a " + interfaceName; + } + return String.valueOf(iface.getMethod(methodName).invoke(instance)); + } catch (java.lang.reflect.InvocationTargetException e) { + return e.getCause().getClass().getName(); + } catch (Exception e) { + return e.getClass().getName(); + } + } + + public static String runExtra(Extra extra) { + return extra.extra(); + } + + // Below minSdk 24, D8 turns this module's default methods into abstract ones, whose + // bodies a class generated on the device cannot reach. Method.isDefault needs API 24. + public static boolean areDefaultsDesugared() throws NoSuchMethodException { + return !Extra.class.getMethod("extraDefault").isDefault(); + } + + public static boolean isRuntimeGenerated(Object instance) { + try { + instance.getClass().getDeclaredField("__initialized"); + return true; + } catch (NoSuchFieldException e) { + return false; + } + } + + // The runtime's cached dex files whose names start with prefix. + public static String[] cachedDexFiles(String prefix) throws Exception { + Context context = (Context) Class.forName("android.app.ActivityThread").getMethod("currentApplication").invoke(null); + List found = new ArrayList(); + File[] dirs = { + new File(context.getApplicationInfo().dataDir, "code_cache/secondary-dexes"), + new File(context.getFilesDir(), "secondary-dexes") + }; + for (File dir : dirs) { + String[] names = dir.list(); + if (names == null) { + continue; + } + for (String name : names) { + if (name.startsWith(prefix) && name.endsWith(".dex")) { + found.add(name); + } + } + } + Collections.sort(found); + return found.toArray(new String[0]); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/MainBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/MainBase.java new file mode 100644 index 000000000..65dd8c491 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/MainBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface MainBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NamedBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NamedBase.java new file mode 100644 index 000000000..cfefedab9 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NamedBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface NamedBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NewWithInterfacesBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NewWithInterfacesBase.java new file mode 100644 index 000000000..61a4926bc --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NewWithInterfacesBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface NewWithInterfacesBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NotAnInterfaceBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NotAnInterfaceBase.java new file mode 100644 index 000000000..dd63691ab --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/NotAnInterfaceBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface NotAnInterfaceBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/OtherExtra.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/OtherExtra.java new file mode 100644 index 000000000..e413fd385 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/OtherExtra.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface OtherExtra { + String other(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/PlainFirstBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/PlainFirstBase.java new file mode 100644 index 000000000..ae1204869 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/PlainFirstBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface PlainFirstBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/TwoSitesBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/TwoSitesBase.java new file mode 100644 index 000000000..21dd83d97 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/TwoSitesBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface TwoSitesBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/TypeScriptBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/TypeScriptBase.java new file mode 100644 index 000000000..1edd9a212 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/TypeScriptBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface TypeScriptBase { + String base(); +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/extras/WorkerBase.java b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/WorkerBase.java new file mode 100644 index 000000000..e80c53a95 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/extras/WorkerBase.java @@ -0,0 +1,5 @@ +package com.tns.tests.interfaces.extras; + +public interface WorkerBase { + String base(); +} diff --git a/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java b/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java index fe3e6227f..c0cedb1f6 100644 --- a/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java +++ b/test-app/build-tools/static-binding-generator/src/main/java/org/nativescript/staticbindinggenerator/Generator.java @@ -147,11 +147,15 @@ public Binding generateBinding(DataRow dataRow, HashSet interfaceNames) String name = ""; Boolean isInterface = clazz.isInterface(); + // An anonymous implementation of an interface that lists interfaces of its own is its + // call site's class, named like a class extend's, as the runtime asks for it; the + // interface's one shared class cannot implement them for a single call site. + boolean isSharedInterfaceClass = isInterface && !hasSpecifiedName && !hasImplementedInterfaces(dataRow); if (hasSpecifiedName) { name = getSimpleClassname(dataRow.getFilename()); } else { - if (isInterface) { + if (isSharedInterfaceClass) { name = getSimpleClassname(clazz.getClassName()); } else { name = getSimpleClassname(clazz.getClassName().replace("$", "_")) + "_"; @@ -162,9 +166,10 @@ public Binding generateBinding(DataRow dataRow, HashSet interfaceNames) } } - if (isInterface && interfaceNames.contains(name)) { + boolean isOneClassPerInterface = isInterface && (hasSpecifiedName || isSharedInterfaceClass); + if (isOneClassPerInterface && interfaceNames.contains(name)) { return null; - } else if (isInterface) { + } else if (isOneClassPerInterface) { interfaceNames.add(name); } @@ -578,6 +583,18 @@ private boolean areAllArgumentsAndReturnTypePublic(ReifiedJavaMethod method) { return true; } + private static boolean hasImplementedInterfaces(DataRow dataRow) { + if (dataRow.getInterfaces() == null) { + return false; + } + for (String interfaceName : dataRow.getInterfaces()) { + if (interfaceName != null && !interfaceName.isEmpty()) { + return true; + } + } + return false; + } + private List getInterfacesFromCache(List interfacesNames) { List interfaces = new ArrayList<>(interfacesNames.size()); diff --git a/test-app/build-tools/static-binding-generator/src/test/java/org/nativescript/staticbindinggenerator/test/GeneratorTest.java b/test-app/build-tools/static-binding-generator/src/test/java/org/nativescript/staticbindinggenerator/test/GeneratorTest.java index 4c4cadc33..53fe395c2 100644 --- a/test-app/build-tools/static-binding-generator/src/test/java/org/nativescript/staticbindinggenerator/test/GeneratorTest.java +++ b/test-app/build-tools/static-binding-generator/src/test/java/org/nativescript/staticbindinggenerator/test/GeneratorTest.java @@ -19,6 +19,7 @@ import java.net.URL; import java.util.ArrayList; import java.util.Arrays; +import java.util.HashSet; import java.util.List; public class GeneratorTest { @@ -153,6 +154,34 @@ public void testCanCompileBindingClassImplementingMultipleInterfaces() throws Ex Assert.assertEquals(4, ComplexClass.getInterfaces().length); // 2 + hashcodeprovider + runtimebound } + @Test + public void testAnInterfaceImplementationWithExtraInterfacesGetsItsCallSiteClass() throws Exception { + Generator generator = new Generator(null, new ArrayList()); + HashSet interfaceNames = new HashSet<>(); + + Binding withExtras = generator.generateBinding(new DataRow("java.lang.Runnable*app_main*9*29**run,update***java.util.Observer"), interfaceNames); + Binding otherExtras = generator.generateBinding(new DataRow("java.lang.Runnable*app_main*12*4**run,formatTo***java.util.Formattable"), interfaceNames); + Binding shared = generator.generateBinding(new DataRow("java.lang.Runnable*app_main*15*4**run***"), interfaceNames); + Binding sharedAgain = generator.generateBinding(new DataRow("java.lang.Runnable*app_main*18*4**run***"), interfaceNames); + + String withExtrasName = withExtras.getFile().getName(); + Assert.assertTrue(withExtrasName, withExtrasName.startsWith("Runnable_app_main_")); + Assert.assertTrue(withExtrasName, withExtrasName.endsWith("_9_29_.java")); + Assert.assertTrue(otherExtras.getFile().getName().endsWith("_12_4_.java")); + Assert.assertEquals("Runnable.java", shared.getFile().getName()); + Assert.assertNull(sharedAgain); + + String className = "com.tns.gen.java.lang." + withExtrasName.substring(0, withExtrasName.length() - ".java".length()); + Iterable options = new ArrayList(Arrays.asList("-cp", dependenciesDir)); + Class compiled = InMemoryJavaCompiler.compile(className, withExtras.getContent(), options); + List> interfaces = Arrays.asList(compiled.getInterfaces()); + Assert.assertTrue(interfaces.contains(Runnable.class)); + Assert.assertTrue(interfaces.contains(java.util.Observer.class)); + + Class sharedClass = InMemoryJavaCompiler.compile("com.tns.gen.java.lang.Runnable", shared.getContent(), options); + Assert.assertFalse(Arrays.asList(sharedClass.getInterfaces()).contains(java.util.Observer.class)); + } + @Test public void testCanCompileBindingClassExtendingAnExtendedClassWithMethodsWithTheSameSignature() throws Exception { URL u = ListView.class.getResource('/' + ListView.class.getName().replace('.', '/') + ".class"); diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java index 5c35aaef6..9e22308a4 100644 --- a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java @@ -34,7 +34,7 @@ private DefaultMethods() { * forward to the method they bridge. */ public static List collect(Class iface) { - return collect(Collections.>singletonList(iface), Collections.emptySet()); + return collect(Collections.>singletonList(iface), Collections.emptySet(), false); } /** @@ -42,24 +42,49 @@ public static List collect(Class iface) { * inherits: as {@link #collect(Class)}, less those a class in the hierarchy declares. */ public static List collect(Class clazz, Collection> interfaces) { - List> roots = new ArrayList<>(interfaces); - Set classSignatures = new HashSet<>(); + return collect(clazz, interfaces, false); + } + + /** + * As {@link #collect(Class, Collection)}, plus one of the default declarations of each + * signature that several unrelated interfaces declare. The subclass has to override such + * a method itself, so it is a candidate only for a class that implements it in JS. + */ + public static List collectWithConflicts(Class clazz, Collection> interfaces) { + return collect(clazz, interfaces, true); + } + + private static List collect(Class clazz, Collection> interfaces, boolean withConflicts) { + // A class listed among the interfaces is not implemented, so it overrides nothing. + List> roots = new ArrayList<>(); + for (Class iface : interfaces) { + if (iface.isInterface()) { + roots.add(iface); + } + } + // A class method overrides a default of the same return type only: Java calls one of + // another return type through a descriptor the class does not declare. + Set classDescriptors = new HashSet<>(); for (Class current = clazz; current != null; current = current.getSuperclass()) { roots.addAll(Arrays.asList(current.getInterfaces())); for (Method method : current.getDeclaredMethods()) { if (!Modifier.isStatic(method.getModifiers())) { - classSignatures.add(signature(method)); + classDescriptors.add(descriptor(method)); } } } - return collect(roots, classSignatures); + return collect(roots, classDescriptors, withConflicts); } private static String signature(Method method) { return method.getName() + Arrays.toString(method.getParameterTypes()); } - private static List collect(Collection> roots, Set excludedSignatures) { + private static String descriptor(Method method) { + return signature(method) + method.getReturnType().getName(); + } + + private static List collect(Collection> roots, Set excludedDescriptors, boolean withConflicts) { Map> declarationsBySignature = new LinkedHashMap<>(); List bridges = new ArrayList<>(); Set> visited = new HashSet<>(); @@ -81,10 +106,10 @@ private static List collect(Collection> roots, Set excl if (method.isSynthetic()) { continue; } - String signature = signature(method); - if (excludedSignatures.contains(signature)) { + if (excludedDescriptors.contains(descriptor(method))) { continue; } + String signature = signature(method); List declarations = declarationsBySignature.get(signature); if (declarations == null) { declarations = new ArrayList<>(); @@ -98,6 +123,7 @@ private static List collect(Collection> roots, Set excl List result = new ArrayList<>(); for (List declarations : declarationsBySignature.values()) { Method mostSpecific = null; + List conflictingDefaults = new ArrayList<>(); int maximal = 0; for (Method candidate : declarations) { boolean overridden = false; @@ -111,12 +137,20 @@ private static List collect(Collection> roots, Set excl if (!overridden) { mostSpecific = candidate; maximal++; + if (candidate.isDefault() && !hasReturnTypeOf(conflictingDefaults, candidate)) { + conflictingDefaults.add(candidate); + } } } // Several maximal declarations conflict, and the class must override them - // itself; that case keeps whatever it does without this class. + // itself; unless asked for, that case keeps whatever it does without this class. + // A bridge covering one of them is itself one side of the conflict, so only an + // override resolves it, bridged or not. Java calls each return type's declaration + // by its own descriptor, so one declaration per return type is kept. if (maximal == 1 && mostSpecific.isDefault() && !isBridged(mostSpecific, bridges)) { result.add(mostSpecific); + } else if (maximal > 1 && withConflicts) { + result.addAll(conflictingDefaults); } } @@ -130,6 +164,15 @@ public int compare(Method a, Method b) { return result; } + private static boolean hasReturnTypeOf(List methods, Method method) { + for (Method other : methods) { + if (other.getReturnType() == method.getReturnType()) { + return true; + } + } + return false; + } + /* * Whether a sub-interface of the method's declaring interface has a bridge of the same * name, parameter and return types: a call of that signature runs the bridge, which forwards diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/Dump.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/Dump.java index f8c248fb6..a4c6cf616 100644 --- a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/Dump.java +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/Dump.java @@ -181,9 +181,9 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto /** * defaultMethods, for an anonymous interface implementation (a proxyName without '.'), * are the interface's DefaultMethods.collect: the class gets the DEFAULT_OVERRIDING_SUFFIX - * name and a stub for each of them as well. For a class or a named interface - * implementation, they are inherited default methods the JS object implements, stubbed - * like the class's other overrides. null adds neither. + * name and a stub for each of them as well. For a class, or an interface implementation + * with a dotted proxyName (one extend() call's class), they are inherited default methods + * the JS object implements, stubbed like the class's other overrides. null adds neither. */ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescriptor classTo, HashSet methodOverrides, HashSet implementedInterfaces, AnnotationDescriptor[] annotations, List defaultMethods) { generateProxy(aw, proxyName, classTo, methodOverrides, implementedInterfaces, annotations, defaultMethods, DefaultMethodBodies.INVOKE_SUPER); @@ -250,13 +250,13 @@ public static String defaultOverridingDescriptor(ClassDescriptor iface, DefaultM private MethodDescriptor[] withInheritedDefaults(MethodDescriptor[] methods, List defaultMethods) { List result = new ArrayList(Arrays.asList(methods)); - Set signatures = new HashSet(); + Set stubs = new HashSet(); for (MethodDescriptor method : methods) { - signatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method)); + addStub(stubs, method, method.isInterfaceMethod()); } for (java.lang.reflect.Method defaultMethod : defaultMethods) { MethodDescriptor method = new MethodInfo(defaultMethod); - if (signatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method))) { + if (addStub(stubs, method, true)) { result.add(method); } } @@ -264,16 +264,16 @@ private MethodDescriptor[] withInheritedDefaults(MethodDescriptor[] methods, Lis } private void generateDefaultMethodStubs(ClassVisitor cv, List defaultMethods, MethodDescriptor[] generatedMethods, String classSignature, String tnsClassSignature, DefaultMethodBodies bodies) { - Set generatedSignatures = new HashSet(); + Set stubs = new HashSet(); for (MethodDescriptor generated : generatedMethods) { - generatedSignatures.add(generated.getName() + "_" + getMethodOverloadDescriptor(generated)); + addStub(stubs, generated, generated.isInterfaceMethod()); } List names = new ArrayList(new TreeSet(namesOf(defaultMethods))); for (java.lang.reflect.Method defaultMethod : defaultMethods) { int bit = names.indexOf(defaultMethod.getName()); MethodDescriptor method = new MethodInfo(defaultMethod); - if (bit >= DefaultMethods.MAX_DISPATCHED_NAMES || !generatedSignatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method))) { + if (bit >= DefaultMethods.MAX_DISPATCHED_NAMES || !addStub(stubs, method, true)) { continue; } generateDefaultMethodStub(cv, defaultMethod, method, bit, classSignature, tnsClassSignature, bodies); @@ -356,19 +356,45 @@ private void generateSuperCall(MethodVisitor mv, MethodDescriptor method, int th private MethodDescriptor[] groupMethodsByNameAndSignature(MethodDescriptor[] methods) { HashMap result = new HashMap(); - for (int i = 0; i < methods.length; i++) { - MethodDescriptor method = methods[i]; - String methodName = method.getName(); - String methodOverLoadDescriptor = getMethodOverloadDescriptor(method); - methodName += "_" + methodOverLoadDescriptor; - if (!result.containsKey(methodName)) { - result.put(methodName, method); + Set descriptors = new HashSet(); + for (MethodDescriptor method : methods) { + String key = stubKey(method, method.isInterfaceMethod()); + if (!result.containsKey(key) && descriptors.add(dexDescriptor(method))) { + result.put(key, method); } } return result.values().toArray(new MethodDescriptor[result.size()]); } + /* + * Which methods of a generated class share one stub. Java calls a method an interface + * declares through its full descriptor, so a class whose interfaces declare it with several + * return types needs a stub for each. A class target's superclass chain keeps one stub per + * name and parameter types: javac's bridges dispatch its other return types to that stub. + */ + private String stubKey(MethodDescriptor method, boolean declaredByInterface) { + return declaredByInterface + ? method.getName() + "(" + getDexMethodDescriptor(method) + : method.getName() + "_" + getMethodOverloadDescriptor(method); + } + + private String dexDescriptor(MethodDescriptor method) { + return method.getName() + getDexMethodDescriptor(method); + } + + // A class cannot declare two methods of one descriptor, whatever their stub keys. + private boolean addStub(Set stubs, MethodDescriptor method, boolean declaredByInterface) { + String descriptor = " " + dexDescriptor(method); + String key = stubKey(method, declaredByInterface); + if (stubs.contains(descriptor) || stubs.contains(key)) { + return false; + } + stubs.add(descriptor); + stubs.add(key); + return true; + } + private String getMethodSignature(MethodDescriptor m) { String sig = m.toGenericString(); @@ -378,13 +404,19 @@ private String getMethodSignature(MethodDescriptor m) { return m.getName() + sig.substring(nameIdx, endSigIdx); } + // Abstract methods found from an interface are told apart by stubKey; those of a class + // target's own hierarchy keep the generic name and parameter list they were found by. + private String collectedKey(MethodDescriptor m, boolean fromInterface) { + return fromInterface ? stubKey(m, true) : getMethodSignature(m); + } + private void collectAbstractMethods(final ClassDescriptor clazz, List result) { if (!clazz.isAbstract()) { return; } Set alreadyAddedMethods = new HashSet(); for (MethodDescriptor md: result) { - String sig = getMethodSignature(md); + String sig = collectedKey(md, clazz.isInterface()); alreadyAddedMethods.add(sig); } @@ -394,7 +426,7 @@ private void collectAbstractMethods(final ClassDescriptor clazz, ListGetDefaultOverrides(isolate, implementationObject); } auto clazz = defaultOverrides != 0 @@ -2034,9 +2036,10 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo(env.NewLocalRef(clazz)); env.InsertClassIntoCache(fullExtendedName, localClass); diff --git a/test-app/runtime/src/main/java/com/tns/DexFactory.java b/test-app/runtime/src/main/java/com/tns/DexFactory.java index fc662c984..0fc384352 100644 --- a/test-app/runtime/src/main/java/com/tns/DexFactory.java +++ b/test-app/runtime/src/main/java/com/tns/DexFactory.java @@ -99,6 +99,13 @@ public Class resolveClass(String baseClassName, String name, String className className = className.substring(0, className.length() - Dump.DEFAULT_OVERRIDING_SUFFIX.length()); } + // Without a base class name, an interface's shared class is asked for (by + // `new Interface({...})` or for its default-overriding variant). It cannot depend on + // the interfaces one implementation object lists. + if (isInterface && baseClassName.isEmpty()) { + implementedInterfaces = new String[0]; + } + String fullClassName = className.replace("$", "_"); String originalFullClassName = fullClassName; @@ -158,9 +165,17 @@ public Class resolveClass(String baseClassName, String name, String className // anonymous form only, where the name is derived from the base. boolean isNamedProxy = !fullClassName.startsWith(COM_TNS_GEN_PREFIX) && fullClassName.contains("."); + // An anonymous extend of an interface that lists interfaces of its own gets a class of + // its call site, under the name asked for, which is also the name a prebuilt class of + // the call site has: the interface's shared class cannot implement them for one call. + boolean isCallSiteInterfaceClass = isInterface && !baseClassName.isEmpty() && !isNamedProxy && implementedInterfaces.length > 0; + if (isCallSiteInterfaceClass) { + desiredDexClassName = fullClassName; + } + // when interfaces are extended as classes, we still want to preserve // just the interface name without the extra file, line, column information - if (!baseClassName.isEmpty() && isInterface && !isNamedProxy) { + if (!baseClassName.isEmpty() && isInterface && !isNamedProxy && !isCallSiteInterfaceClass) { fullClassName = COM_TNS_GEN_PREFIX + classToProxy; } @@ -180,7 +195,7 @@ public Class resolveClass(String baseClassName, String name, String className } String dexFilePath; - if (isInterface && !isNamedProxy) { + if (isInterface && !isNamedProxy && !isCallSiteInterfaceClass) { dexFilePath = this.generateDex(name, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, bodies); } else { dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, null); @@ -215,7 +230,7 @@ public Class resolveClass(String baseClassName, String name, String className jarFile.setReadOnly(); Class result = null; - String classNameToLoad = isInterface ? fullClassName : desiredDexClassName; + String classNameToLoad = isInterface && !isCallSiteInterfaceClass ? fullClassName : desiredDexClassName; boolean injectIntoParent = injectIntoParentClassLoader && classLoader instanceof BaseDexClassLoader; if (injectIntoParent && ProxyRegistrationGc.isRequired()) { @@ -424,11 +439,16 @@ private String generateDex(String proxyName, String contentDigest, String classN if (overridesDefaults) { defaultMethods = DefaultMethods.collect(classToProxy); } else if ((!classToProxy.isInterface() || proxyName.contains(".")) && Build.VERSION.SDK_INT >= 24) { - // A named interface implementation is one extend() call's class, so like a class - // it stubs only the default methods its implementation object names. - List inheritedDefaults = classToProxy.isInterface() - ? DefaultMethods.collect(classToProxy) - : DefaultMethods.collect(classToProxy, implementedInterfaceClasses); + // An interface implementation with a dotted name is one extend() call's class, so + // like a class it stubs only the default methods its implementation object names. + List inheritedDefaults; + if (classToProxy.isInterface()) { + List> interfaces = new ArrayList>(implementedInterfaceClasses); + interfaces.add(classToProxy); + inheritedDefaults = DefaultMethods.collectWithConflicts(Object.class, interfaces); + } else { + inheritedDefaults = DefaultMethods.collectWithConflicts(classToProxy, implementedInterfaceClasses); + } defaultMethods = new ArrayList(); for (Method inherited : inheritedDefaults) { if (methodOverridesSet == null || methodOverridesSet.contains(inherited.getName())) { diff --git a/test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java b/test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java index 20928ffbf..28d495fe3 100644 --- a/test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java +++ b/test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java @@ -184,6 +184,7 @@ private static byte[] generate(Class iface, boolean overrideDefaults) { private static final class Shape { String className; + final List interfaces = new ArrayList<>(); final List fields = new ArrayList<>(); final List methods = new ArrayList<>(); } @@ -194,6 +195,9 @@ private static Shape read(byte[] dex) { @Override public ClassVisitor visitClass(int access, String name, String[] signature, String superName, String[] interfaces) { shape.className = name; + if (interfaces != null) { + shape.interfaces.addAll(Arrays.asList(interfaces)); + } return new ClassVisitor(Opcodes.ASM4) { @Override public FieldVisitor visitField(int access, String name, String desc, String[] signature, Object value) { @@ -251,6 +255,229 @@ public void aNamedInterfaceImplementationStubsOnlyTheGivenDefaults() throws Exce assertFalse(shape.methods.contains("removeV")); } + @Test + public void conflictingDefaultsAreCollectedOnlyWhenAskedFor() throws Exception { + List> interfaces = Arrays.>asList(Base.class, Other.class); + assertFalse(DefaultMethods.collect(Object.class, interfaces).contains(Base.class.getMethod("inherited"))); + + List withConflicts = DefaultMethods.collectWithConflicts(Object.class, interfaces); + assertTrue(withConflicts.contains(Base.class.getMethod("inherited"))); + assertFalse(withConflicts.contains(Other.class.getMethod("inherited"))); + assertTrue(withConflicts.containsAll(DefaultMethods.collect(Object.class, interfaces))); + } + + interface ObjectSame { + default Object same(Object value) { + return "object " + value; + } + } + + @Test + public void aConflictWithABridgedDefaultIsCollectedWhenAskedFor() throws Exception { + // Narrowing's bridge same(Object) and ObjectSame.same(Object) conflict in a class + // implementing both, which therefore has to override same(Object) itself. + List> interfaces = Arrays.>asList(Narrowing.class, ObjectSame.class); + Method erased = Generic.class.getMethod("same", Object.class); + Method other = ObjectSame.class.getMethod("same", Object.class); + Method narrowed = Narrowing.class.getMethod("same", String.class); + + List withoutConflicts = DefaultMethods.collect(Object.class, interfaces); + assertEquals(Arrays.asList(narrowed), withoutConflicts); + + List withConflicts = DefaultMethods.collectWithConflicts(Object.class, interfaces); + assertTrue(withConflicts.contains(narrowed)); + assertEquals(1, (withConflicts.contains(erased) ? 1 : 0) + (withConflicts.contains(other) ? 1 : 0)); + assertEquals(2, withConflicts.size()); + } + + interface NumberValue { + default Number value() { + return 1; + } + } + + interface IntegerValue { + default Integer value() { + return 2; + } + } + + interface AbstractNumberAmount { + Number amount(); + } + + interface AbstractIntegerAmount { + Integer amount(); + } + + @Test + public void conflictingDefaultsWithDifferentReturnTypesAreAllCollected() throws Exception { + List withConflicts = DefaultMethods.collectWithConflicts(Object.class, + Arrays.>asList(NumberValue.class, IntegerValue.class)); + assertTrue(withConflicts.contains(NumberValue.class.getMethod("value"))); + assertTrue(withConflicts.contains(IntegerValue.class.getMethod("value"))); + } + + private static Shape generateCallSiteClass(Class base, Class extra, List defaultMethods) { + HashSet extras = new HashSet<>(); + extras.add(new ClassInfo(extra)); + org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter(); + aw.visit(); + new Dump().generateProxy(aw, "com.tns.gen.a.Base_site_1_2_", new ClassInfo(base), null, extras, null, defaultMethods); + aw.visitEnd(); + return read(aw.toByteArray()); + } + + @Test + public void aCallSiteClassStubsEveryReturnTypeOfAMethodItsInterfacesDeclare() throws Exception { + Shape defaults = generateCallSiteClass(NumberValue.class, IntegerValue.class, + Arrays.asList(NumberValue.class.getMethod("value"), IntegerValue.class.getMethod("value"))); + assertTrue(defaults.methods.contains("valueLjava/lang/Number;")); + assertTrue(defaults.methods.contains("valueLjava/lang/Integer;")); + + Shape abstracts = generateCallSiteClass(AbstractNumberAmount.class, AbstractIntegerAmount.class, new ArrayList()); + assertTrue(abstracts.methods.contains("amountLjava/lang/Number;")); + assertTrue(abstracts.methods.contains("amountLjava/lang/Integer;")); + } + + public static class NumberSuper { + public Number value() { + return 1; + } + } + + // javac adds the bridge Number value(), which calls Integer value(). + public static class IntegerSub extends NumberSuper { + @Override + public Integer value() { + return 2; + } + } + + public static class ObjectGetter { + public Object get() { + return null; + } + } + + interface StringGetDefault { + default String get() { + return "default"; + } + } + + interface StringGetAbstract { + String get(); + } + + private static Shape generateClassExtend(Class base, String override, List> interfaces, List defaultMethods) { + HashSet extras = new HashSet<>(); + for (Class iface : interfaces) { + extras.add(new ClassInfo(iface)); + } + HashSet overrides = new HashSet<>(); + overrides.add(override); + org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter(); + aw.visit(); + new Dump().generateProxy(aw, "a.Extend_site_1_2_", new ClassInfo(base), overrides, extras, null, defaultMethods); + aw.visitEnd(); + return read(aw.toByteArray()); + } + + private static List stubsNamed(Shape shape, String name) { + List stubs = new ArrayList<>(); + for (String method : shape.methods) { + // name + dex descriptor, which starts with the return type + if (method.startsWith(name) && method.length() > name.length() && "LVZBCSIJFD[".indexOf(method.charAt(name.length())) >= 0) { + stubs.add(method); + } + } + stubs.sort(null); + return stubs; + } + + @Test + public void aClassExtendKeepsOneStubForASuperclassMethodASubclassNarrows() { + Shape shape = generateClassExtend(IntegerSub.class, "value", new ArrayList>(), new ArrayList()); + assertEquals(Arrays.asList("valueLjava/lang/Integer;"), stubsNamed(shape, "value")); + } + + @Test + public void aClassExtendStubsEveryReturnTypeItsExtraInterfacesDeclare() { + Shape shape = generateClassExtend(Object.class, "amount", + Arrays.>asList(AbstractNumberAmount.class, AbstractIntegerAmount.class), new ArrayList()); + assertEquals(Arrays.asList("amountLjava/lang/Integer;", "amountLjava/lang/Number;"), stubsNamed(shape, "amount")); + } + + @Test + public void aClassExtendStubsTheReturnTypeAnExtraInterfaceAddsToASuperclassMethod() throws Exception { + assertEquals(Arrays.asList("getLjava/lang/Object;"), + stubsNamed(generateClassExtend(ObjectGetter.class, "get", new ArrayList>(), new ArrayList()), "get")); + + assertEquals(Arrays.asList("getLjava/lang/Object;", "getLjava/lang/String;"), + stubsNamed(generateClassExtend(ObjectGetter.class, "get", Arrays.>asList(StringGetAbstract.class), new ArrayList()), "get")); + + List> withDefault = Arrays.>asList(StringGetDefault.class); + List defaults = DefaultMethods.collectWithConflicts(ObjectGetter.class, withDefault); + assertEquals(Arrays.asList(StringGetDefault.class.getMethod("get")), defaults); + assertEquals(Arrays.asList("getLjava/lang/Object;", "getLjava/lang/String;"), + stubsNamed(generateClassExtend(ObjectGetter.class, "get", withDefault, defaults), "get")); + } + + interface ListedBase { + default String value() { + return "base"; + } + } + + abstract static class ListedImplementor implements ListedBase { + @Override + public String value() { + return "class"; + } + } + + @Test + public void aClassAmongTheInterfacesTakesNoPartInTheDefaults() throws Exception { + List collected = DefaultMethods.collectWithConflicts(Object.class, + Arrays.>asList(ListedBase.class, ListedImplementor.class)); + assertEquals(Arrays.asList(ListedBase.class.getMethod("value")), collected); + } + + abstract static class NotAnInterface { + public abstract String fromClass(); + } + + @Test + public void anInterfaceImplementationOfOneCallSiteImplementsItsOtherInterfacesOnce() throws Exception { + HashSet extras = new HashSet<>(); + extras.add(new ClassInfo(Other.class)); + extras.add(new ClassInfo(Iterator.class)); + extras.add(new ClassInfo(Runnable.class)); + extras.add(new ClassInfo(NotAnInterface.class)); + List named = new ArrayList<>(); + named.add(Other.class.getMethod("inherited")); + + org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter(); + aw.visit(); + new Dump().generateProxy(aw, "com.tns.gen.java.util.Iterator_site_1_2_", new ClassInfo(Iterator.class), null, extras, null, named); + aw.visitEnd(); + Shape shape = read(aw.toByteArray()); + + assertEquals("Lcom/tns/gen/java/util/Iterator_site_1_2_;", shape.className); + List interfaces = new ArrayList<>(shape.interfaces); + interfaces.sort(null); + assertEquals(Arrays.asList( + "Lcom/tns/NativeScriptHashCodeProvider;", + "Lcom/tns/NativeScriptRuntimeBound;", + "Lcom/tns/bindings/DefaultMethodsTest$Other;", + "Ljava/lang/Runnable;", + "Ljava/util/Iterator;"), interfaces); + assertTrue(shape.methods.contains("runV")); + assertTrue(shape.methods.contains("inheritedLjava/lang/String;")); + assertFalse(shape.fields.contains("defaultOverrides__ns:J")); + } + interface HiddenBase { default String hidden() { return "hidden";