From f3295b998d9fe81c31468ef50ad926dba518f9ee Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 11:23:05 -0300 Subject: [PATCH 1/6] fix(bindings): implement the extra interfaces of an interface extend An extend() of a Java interface that lists more interfaces in `interfaces` produced a class that did not implement them: the generator added the extra interfaces to the implemented list only for class bases, so Java could neither cast the instance to one of them nor pass it where one is expected. An unnamed extend also got the interface's shared com.tns.gen. class, under which the first class loaded wins, so it could even miss the extra interfaces' methods, a second extend call site got the first one's class and implementation, and in a worker the constructor generated a class for the shared name again and failed. Such an extend now gets a class of its own call site, generated and loaded under the call-site name native asks for (a named extend keeps its name). It implements the base and every extra interface once, stubs their abstract methods and the default methods the JS object implements, including one that the base and an extra both declare, and its dex is cached under that name. The constructor uses the class the extend resolved. `new Interface({...})` no longer passes its `interfaces` to the interface's shared class, whose body therefore no longer depends on the instance that created it first. --- test-app/.gitignore | 1 + test-app/app/src/main/assets/app/mainpage.js | 1 + .../tests/interfaceExtraInterfacesWorker.js | 21 ++ .../app/tests/testInterfaceExtraInterfaces.js | 343 ++++++++++++++++++ .../interfaces/extras/AbstractExtra.java | 6 + .../tns/tests/interfaces/extras/Bases.java | 10 + .../tests/interfaces/extras/CacheBase.java | 5 + .../tests/interfaces/extras/ConflictBase.java | 10 + .../interfaces/extras/ConflictExtra.java | 7 + .../tests/interfaces/extras/DefaultsBase.java | 9 + .../interfaces/extras/DuplicateBase.java | 5 + .../tns/tests/interfaces/extras/Extra.java | 9 + .../interfaces/extras/ExtrasFirstBase.java | 5 + .../interfaces/extras/ExtrasFixtures.java | 101 ++++++ .../tns/tests/interfaces/extras/MainBase.java | 5 + .../tests/interfaces/extras/NamedBase.java | 5 + .../extras/NewWithInterfacesBase.java | 5 + .../interfaces/extras/NotAnInterfaceBase.java | 5 + .../tests/interfaces/extras/OtherExtra.java | 5 + .../interfaces/extras/PlainFirstBase.java | 5 + .../tests/interfaces/extras/TwoSitesBase.java | 5 + .../interfaces/extras/TypeScriptBase.java | 5 + .../tests/interfaces/extras/WorkerBase.java | 5 + .../java/com/tns/bindings/DefaultMethods.java | 29 +- .../src/main/java/com/tns/bindings/Dump.java | 15 +- .../runtime/src/main/cpp/MetadataNode.cpp | 11 +- .../src/main/java/com/tns/DexFactory.java | 36 +- .../com/tns/bindings/DefaultMethodsTest.java | 73 ++++ 28 files changed, 723 insertions(+), 19 deletions(-) create mode 100644 test-app/app/src/main/assets/app/tests/interfaceExtraInterfacesWorker.js create mode 100644 test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/AbstractExtra.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/Bases.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/CacheBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/ConflictExtra.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/DefaultsBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/DuplicateBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/Extra.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFirstBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/ExtrasFixtures.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/MainBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/NamedBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/NewWithInterfacesBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/NotAnInterfaceBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/OtherExtra.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/PlainFirstBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/TwoSitesBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/TypeScriptBase.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/WorkerBase.java 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..bded10dc4 --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -0,0 +1,343 @@ +// 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"); + }); + + 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. + it("are prebuilt with the extra interfaces of a named extend", function () { + 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/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/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/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..60fd810b8 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,6 +42,19 @@ 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) { + 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) { List> roots = new ArrayList<>(interfaces); Set classSignatures = new HashSet<>(); for (Class current = clazz; current != null; current = current.getSuperclass()) { @@ -52,14 +65,14 @@ public static List collect(Class clazz, Collection> interfac } } } - return collect(roots, classSignatures); + return collect(roots, classSignatures, withConflicts); } private static String signature(Method method) { return method.getName() + Arrays.toString(method.getParameterTypes()); } - private static List collect(Collection> roots, Set excludedSignatures) { + private static List collect(Collection> roots, Set excludedSignatures, boolean withConflicts) { Map> declarationsBySignature = new LinkedHashMap<>(); List bridges = new ArrayList<>(); Set> visited = new HashSet<>(); @@ -98,6 +111,7 @@ private static List collect(Collection> roots, Set excl List result = new ArrayList<>(); for (List declarations : declarationsBySignature.values()) { Method mostSpecific = null; + Method conflictingDefault = null; int maximal = 0; for (Method candidate : declarations) { boolean overridden = false; @@ -111,12 +125,19 @@ private static List collect(Collection> roots, Set excl if (!overridden) { mostSpecific = candidate; maximal++; + if (conflictingDefault == null && candidate.isDefault()) { + conflictingDefault = 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. if (maximal == 1 && mostSpecific.isDefault() && !isBridged(mostSpecific, bridges)) { result.add(mostSpecific); + } else if (maximal > 1 && withConflicts && conflictingDefault != null) { + result.add(conflictingDefault); } } 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..5b97799ab 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); @@ -1009,6 +1009,15 @@ private ClassVisitor generateClass(ApplicationWriter aw, ClassDescriptor classTo if (!interfacesToImplement.contains(classSignature)) { interfacesToImplement.add(classSignature); } + if (implementedInterfaces != null) { + for (ClassDescriptor interfaceToImpl : implementedInterfaces) { + // A class listed there cannot be implemented. + String descriptor = getAsmDescriptor(interfaceToImpl); + if (interfaceToImpl.isInterface() && !interfacesToImplement.contains(descriptor)) { + interfacesToImplement.add(descriptor); + } + } + } classSignature = objectClass; } else { diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp index a9a6912f5..0883e0f70 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.cpp +++ b/test-app/runtime/src/main/cpp/MetadataNode.cpp @@ -2026,7 +2026,9 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfoGetDefaultOverrides(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..571e810ca 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,75 @@ 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()); + } + + 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"; From 5b5db71036db8eb5d3b007164102840bc897b3b6 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 11:23:17 -0300 Subject: [PATCH 2/6] fix(sbg): prebuild an interface extend with extra interfaces under its call-site name The static binding generator builds one class per interface, named after it, from the first row it parses, so the extra interfaces of an interface extend leaked into that shared class: every `new Interface({...})` and extend without extra interfaces of the app then implemented them too, while other extends with different extra interfaces lacked theirs. An unnamed interface row with at least one extra interface now gets the class-row name the runtime looks a call site's prebuilt class up by, and stays out of the one-class-per-interface rule. Rows without extra interfaces, named rows and class rows are generated as before. --- .../app/tests/testInterfaceExtraInterfaces.js | 21 ++++++++++++++ .../staticbindinggenerator/Generator.java | 23 +++++++++++++-- .../test/GeneratorTest.java | 29 +++++++++++++++++++ 3 files changed, 70 insertions(+), 3 deletions(-) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js index bded10dc4..b1fcc00f3 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -327,6 +327,27 @@ describe("Interface extends with extra interfaces", function () { }, 30000); // Named in full, so the static binding generator prebuilds their classes. + it("are prebuilt under the call-site class name, apart from the base's shared class", function () { + 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 () { var Named = java.util.function.DoubleSupplier.extend("com.tns.tests.extras.NamedPrebuiltExtras", { interfaces: [java.util.function.BooleanSupplier], 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"); From 4badb06f63ac31e65bd0822be33f24cca924eb1d Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 17:42:26 -0300 Subject: [PATCH 3/6] fix(bindings): stub every return type of a method an implementation inherits twice A class that implements unrelated interfaces declaring the same method with different return types, such as Number value() and Integer value(), is called through a separate dex method for each return type. Only one of them got a stub: the conflicting defaults kept one declaration, and the generator keyed its stubs by name and parameter types, so it also merged abstract declarations that differ in return type. A Java caller holding the instance as the other type ran the interface's body or hit an AbstractMethodError instead of the JS implementation. With D8 desugaring the app's default methods into abstract ones, that also applies to defaults below minSdk 24. The conflicting defaults keep one declaration per return type, and the generator keys methods by name and full dex descriptor, so each return type the class can be called through gets a stub. --- .../app/tests/testInterfaceExtraInterfaces.js | 43 ++++++++++++++++ .../tests/interfaces/extras/Covariant.java | 34 +++++++++++++ .../java/com/tns/bindings/DefaultMethods.java | 22 +++++--- .../src/main/java/com/tns/bindings/Dump.java | 35 ++++++------- .../com/tns/bindings/DefaultMethodsTest.java | 50 +++++++++++++++++++ 5 files changed, 159 insertions(+), 25 deletions(-) create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/Covariant.java diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js index b1fcc00f3..cfff1e93f 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -263,6 +263,49 @@ describe("Interface extends with extra interfaces", function () { 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("cache their dex under the class's own name", function () { var B = X.CacheBase; var C = B.extend({ 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/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 60fd810b8..9c0a03aad 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 @@ -111,7 +111,7 @@ private static List collect(Collection> roots, Set excl List result = new ArrayList<>(); for (List declarations : declarationsBySignature.values()) { Method mostSpecific = null; - Method conflictingDefault = null; + List conflictingDefaults = new ArrayList<>(); int maximal = 0; for (Method candidate : declarations) { boolean overridden = false; @@ -125,19 +125,20 @@ private static List collect(Collection> roots, Set excl if (!overridden) { mostSpecific = candidate; maximal++; - if (conflictingDefault == null && candidate.isDefault()) { - conflictingDefault = candidate; + if (candidate.isDefault() && !hasReturnTypeOf(conflictingDefaults, candidate)) { + conflictingDefaults.add(candidate); } } } // Several maximal declarations conflict, and the class must override them // 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. + // 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 && conflictingDefault != null) { - result.add(conflictingDefault); + } else if (maximal > 1 && withConflicts) { + result.addAll(conflictingDefaults); } } @@ -151,6 +152,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 5b97799ab..db2430276 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 @@ -252,11 +252,11 @@ private MethodDescriptor[] withInheritedDefaults(MethodDescriptor[] methods, Lis List result = new ArrayList(Arrays.asList(methods)); Set signatures = new HashSet(); for (MethodDescriptor method : methods) { - signatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method)); + signatures.add(methodKey(method)); } for (java.lang.reflect.Method defaultMethod : defaultMethods) { MethodDescriptor method = new MethodInfo(defaultMethod); - if (signatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method))) { + if (signatures.add(methodKey(method))) { result.add(method); } } @@ -266,14 +266,14 @@ 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(); for (MethodDescriptor generated : generatedMethods) { - generatedSignatures.add(generated.getName() + "_" + getMethodOverloadDescriptor(generated)); + generatedSignatures.add(methodKey(generated)); } 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 || !generatedSignatures.add(methodKey(method))) { continue; } generateDefaultMethodStub(cv, defaultMethod, method, bit, classSignature, tnsClassSignature, bodies); @@ -358,24 +358,21 @@ private MethodDescriptor[] groupMethodsByNameAndSignature(MethodDescriptor[] met 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); + String key = methodKey(method); + if (!result.containsKey(key)) { + result.put(key, method); } } return result.values().toArray(new MethodDescriptor[result.size()]); } - private String getMethodSignature(MethodDescriptor m) { - String sig = m.toGenericString(); - - int nameIdx = sig.indexOf("("); - int endSigIdx = sig.indexOf(")") + 1; - - return m.getName() + sig.substring(nameIdx, endSigIdx); + /* + * A method's identity in dex, return type included: a method narrowing another's return + * type is called through both descriptors, and each one needs its own implementation. + */ + private String methodKey(MethodDescriptor m) { + return m.getName() + getDexMethodDescriptor(m); } private void collectAbstractMethods(final ClassDescriptor clazz, List result) { @@ -384,7 +381,7 @@ private void collectAbstractMethods(final ClassDescriptor clazz, List alreadyAddedMethods = new HashSet(); for (MethodDescriptor md: result) { - String sig = getMethodSignature(md); + String sig = methodKey(md); alreadyAddedMethods.add(sig); } @@ -394,7 +391,7 @@ private void collectAbstractMethods(final ClassDescriptor clazz, 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;")); + } + abstract static class NotAnInterface { public abstract String fromClass(); } From bd42795b14f0d9156efa775662f8f41d4afd1fde Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 17:42:45 -0300 Subject: [PATCH 4/6] fix(bindings): leave a class listed in interfaces out of the default methods A class listed in an extend's `interfaces` is not implemented, but it still took part in collecting the default methods to stub. A concrete method it declares counted as overriding the interface's default, so a default the JS object implements, such as Base.value() next to a listed abstract class that implements Base, got no stub, and Java ran the interface's body instead of the JS implementation. Only the interfaces among the listed types are now considered. --- .../app/tests/testInterfaceExtraInterfaces.js | 12 +++++++++++ .../tests/interfaces/extras/ClassListed.java | 20 +++++++++++++++++++ .../java/com/tns/bindings/DefaultMethods.java | 8 +++++++- .../com/tns/bindings/DefaultMethodsTest.java | 20 +++++++++++++++++++ 4 files changed, 59 insertions(+), 1 deletion(-) create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/extras/ClassListed.java diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js index cfff1e93f..2b891e274 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -306,6 +306,18 @@ describe("Interface extends with extra interfaces", function () { expect(String(F.call(instance, PKG + "Covariant$AbstractIntegerExtra", "amount"))).toBe("42"); }); + 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({ 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/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 9c0a03aad..0be4a52ea 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 @@ -55,7 +55,13 @@ public static List collectWithConflicts(Class clazz, Collection collect(Class clazz, Collection> interfaces, boolean withConflicts) { - List> roots = new ArrayList<>(interfaces); + // 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); + } + } Set classSignatures = new HashSet<>(); for (Class current = clazz; current != null; current = current.getSuperclass()) { roots.addAll(Arrays.asList(current.getInterfaces())); 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 394cead49..09b503d8c 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 @@ -340,6 +340,26 @@ public void aCallSiteClassStubsEveryReturnTypeOfAMethodItsInterfacesDeclare() th assertTrue(abstracts.methods.contains("amountLjava/lang/Integer;")); } + 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(); } From 4ad3f04e97b6e7c8c157071fd3671c4ade095862 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 17:43:00 -0300 Subject: [PATCH 5/6] test: skip the java.util.function prebuilt extend specs below API 24 The two specs whose call sites the static binding generator prebuilds use java.util.function interfaces, which exist from API 24, while the test app runs from API 21. --- .../assets/app/tests/testInterfaceExtraInterfaces.js | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js index 2b891e274..8bbc9f63b 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -381,8 +381,12 @@ describe("Interface extends with extra interfaces", function () { }; }, 30000); - // Named in full, so the static binding generator prebuilds their classes. + // 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; }, @@ -404,6 +408,9 @@ describe("Interface extends with extra interfaces", function () { }); 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; }, From 8b7ed3d55fd031d4a297b7a3275d4a845c095cbb Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 17:57:11 -0300 Subject: [PATCH 6/6] fix(bindings): keep one stub per superclass method of a class extend Stubs were keyed by full dex descriptor for every method, so a class extend whose JS object overrides a superclass method that a subclass narrows got a stub for each return type, where javac's bridge already dispatches the other one to the single stub it had. A superclass method also kept out an interface's default of another return type, so a class extend whose extra interface declares the method with a different return type ran the interface's body, or hit an AbstractMethodError for an abstract declaration, instead of the JS implementation. Only methods that come from interfaces are now keyed by their full descriptor; the superclass chain keeps one stub per name and parameter types, which generates the same class as before for a class extend without such interfaces. A class method keeps out only a default of its own return type, and no two stubs share a descriptor. --- .../app/tests/testInterfaceExtraInterfaces.js | 12 +++ .../java/com/tns/bindings/DefaultMethods.java | 18 ++-- .../src/main/java/com/tns/bindings/Dump.java | 69 +++++++++++---- .../com/tns/bindings/DefaultMethodsTest.java | 84 +++++++++++++++++++ 4 files changed, 160 insertions(+), 23 deletions(-) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js index 8bbc9f63b..c6ab41025 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceExtraInterfaces.js @@ -306,6 +306,18 @@ describe("Interface extends with extra interfaces", function () { 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", { 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 0be4a52ea..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 @@ -62,23 +62,29 @@ private static List collect(Class clazz, Collection> interfa roots.add(iface); } } - Set classSignatures = new HashSet<>(); + // 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, withConflicts); + 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, boolean withConflicts) { + 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<>(); @@ -100,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<>(); 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 db2430276..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 @@ -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(methodKey(method)); + addStub(stubs, method, method.isInterfaceMethod()); } for (java.lang.reflect.Method defaultMethod : defaultMethods) { MethodDescriptor method = new MethodInfo(defaultMethod); - if (signatures.add(methodKey(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(methodKey(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(methodKey(method))) { + if (bit >= DefaultMethods.MAX_DISPATCHED_NAMES || !addStub(stubs, method, true)) { continue; } generateDefaultMethodStub(cv, defaultMethod, method, bit, classSignature, tnsClassSignature, bodies); @@ -356,10 +356,10 @@ 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 key = methodKey(method); - if (!result.containsKey(key)) { + 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); } } @@ -368,11 +368,46 @@ private MethodDescriptor[] groupMethodsByNameAndSignature(MethodDescriptor[] met } /* - * A method's identity in dex, return type included: a method narrowing another's return - * type is called through both descriptors, and each one needs its own implementation. + * 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 methodKey(MethodDescriptor m) { - return m.getName() + getDexMethodDescriptor(m); + 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(); + + int nameIdx = sig.indexOf("("); + int endSigIdx = sig.indexOf(")") + 1; + + 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) { @@ -381,7 +416,7 @@ private void collectAbstractMethods(final ClassDescriptor clazz, List alreadyAddedMethods = new HashSet(); for (MethodDescriptor md: result) { - String sig = methodKey(md); + String sig = collectedKey(md, clazz.isInterface()); alreadyAddedMethods.add(sig); } @@ -391,7 +426,7 @@ private void collectAbstractMethods(final ClassDescriptor clazz, List 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";