From d573d46fa93d6f51f0b314197033ef6994ee6d37 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 03:09:28 -0300 Subject: [PATCH 01/16] feat(runtime): call an interface's default method non-virtually from Java Add Runtime.invokeInterfaceDefault, which runs an interface's default method body on a receiver whose class overrides that method, the way invokespecial would: a JNI CallNonvirtualMethodA on the interface's jmethodID. Primitive arguments and results cross the JNI boundary as raw bits, and an exception the method throws stays pending, so it reaches the Java caller with its own type. Copied unchanged from the interface proxy work, so both changes add the same lines. --- .../runtime/src/main/cpp/com_tns_Runtime.cpp | 68 +++++++++++++++ .../src/main/java/com/tns/Runtime.java | 82 +++++++++++++++++++ 2 files changed, 150 insertions(+) diff --git a/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp b/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp index c2c09ff3d..44e2d103f 100644 --- a/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp +++ b/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp @@ -3,7 +3,9 @@ #include "NativeScriptException.h" #include "CallbackHandlers.h" #include "ArgConverter.h" +#include #include +#include #include using namespace std; @@ -386,3 +388,69 @@ extern "C" JNIEXPORT void Java_com_tns_Runtime_ResetDateTimeConfigurationCache(J extern "C" JNIEXPORT void Java_com_tns_Runtime_setAdmissionSpinMicros(JNIEnv* _env, jclass clazz, jint micros) { AdmissionGate::s_spinMicros.store(micros, std::memory_order_relaxed); } + +// Raw JNI throughout: an exception the method throws must stay pending, so that it reaches +// the Java caller unchanged. +extern "C" JNIEXPORT jobject Java_com_tns_Runtime_invokeNonvirtualNative(JNIEnv* env, jclass, jobject receiver, jobject method, jclass declaringClass, jstring shorty, + jlongArray primitiveArgs, jobjectArray args, jlongArray primitiveResult) { + jmethodID mid = env->FromReflectedMethod(method); + + const char* chars = env->GetStringUTFChars(shorty, nullptr); + string types(chars); + env->ReleaseStringUTFChars(shorty, chars); + + size_t argc = types.size() - 1; + vector values(argc > 0 ? argc : 1); + vector bits(argc); + if (argc > 0 && primitiveArgs != nullptr) { + env->GetLongArrayRegion(primitiveArgs, 0, static_cast(argc), bits.data()); + } + for (size_t i = 0; i < argc; i++) { + jvalue& value = values[i]; + switch (types[i + 1]) { + case 'Z': value.z = bits[i] != 0 ? JNI_TRUE : JNI_FALSE; break; + case 'B': value.b = static_cast(bits[i]); break; + case 'C': value.c = static_cast(bits[i]); break; + case 'S': value.s = static_cast(bits[i]); break; + case 'I': value.i = static_cast(bits[i]); break; + case 'J': value.j = bits[i]; break; + case 'F': { + auto raw = static_cast(bits[i]); + memcpy(&value.f, &raw, sizeof(value.f)); + break; + } + case 'D': memcpy(&value.d, &bits[i], sizeof(value.d)); break; + default: value.l = env->GetObjectArrayElement(args, static_cast(i)); break; + } + } + + jlong result = 0; + jobject objectResult = nullptr; + switch (types[0]) { + case 'V': env->CallNonvirtualVoidMethodA(receiver, declaringClass, mid, values.data()); break; + case 'Z': result = env->CallNonvirtualBooleanMethodA(receiver, declaringClass, mid, values.data()); break; + case 'B': result = env->CallNonvirtualByteMethodA(receiver, declaringClass, mid, values.data()); break; + case 'C': result = env->CallNonvirtualCharMethodA(receiver, declaringClass, mid, values.data()); break; + case 'S': result = env->CallNonvirtualShortMethodA(receiver, declaringClass, mid, values.data()); break; + case 'I': result = env->CallNonvirtualIntMethodA(receiver, declaringClass, mid, values.data()); break; + case 'J': result = env->CallNonvirtualLongMethodA(receiver, declaringClass, mid, values.data()); break; + case 'F': { + jfloat f = env->CallNonvirtualFloatMethodA(receiver, declaringClass, mid, values.data()); + int32_t raw; + memcpy(&raw, &f, sizeof(raw)); + result = raw; + break; + } + case 'D': { + jdouble d = env->CallNonvirtualDoubleMethodA(receiver, declaringClass, mid, values.data()); + memcpy(&result, &d, sizeof(result)); + break; + } + default: objectResult = env->CallNonvirtualObjectMethodA(receiver, declaringClass, mid, values.data()); break; + } + + if (primitiveResult != nullptr && !env->ExceptionCheck()) { + env->SetLongArrayRegion(primitiveResult, 0, 1, &result); + } + return objectResult; +} diff --git a/test-app/runtime/src/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java index 75ec2758c..dd7d12d2e 100644 --- a/test-app/runtime/src/main/java/com/tns/Runtime.java +++ b/test-app/runtime/src/main/java/com/tns/Runtime.java @@ -1658,6 +1658,88 @@ private static Object takePrimitiveResult(Object nativeResult, int returnType, l } } + // shorty: the JNI shorty of the method, return type first; primitive arguments travel as + // raw bits in primitiveArgs, references in args. A primitive result comes back in + // primitiveResult[0] as raw bits. + private static native Object invokeNonvirtualNative(Object receiver, Method method, Class declaringClass, String shorty, long[] primitiveArgs, Object[] args, long[] primitiveResult); + + /* + * Runs an interface's default method on an instance whose class does not override it, + * the way invokespecial would: a virtual call would come straight back to the proxy. + */ + static Object invokeInterfaceDefault(Object receiver, Method method, Object[] args) { + Class[] parameterTypes = method.getParameterTypes(); + Class returnType = method.getReturnType(); + char[] shorty = new char[parameterTypes.length + 1]; + shorty[0] = shortyChar(returnType); + long[] primitiveArgs = parameterTypes.length > 0 ? new long[parameterTypes.length] : null; + for (int i = 0; i < parameterTypes.length; i++) { + shorty[i + 1] = shortyChar(parameterTypes[i]); + if (parameterTypes[i].isPrimitive()) { + primitiveArgs[i] = rawBits(args[i]); + } + } + boolean primitiveReturn = returnType.isPrimitive() && returnType != void.class; + long[] primitiveResult = primitiveReturn ? new long[1] : null; + Object result = invokeNonvirtualNative(receiver, method, method.getDeclaringClass(), new String(shorty), primitiveArgs, args, primitiveResult); + return primitiveReturn ? fromRawBits(returnType, primitiveResult[0]) : result; + } + + private static char shortyChar(Class type) { + if (!type.isPrimitive()) { + return 'L'; + } else if (type == boolean.class) { + return 'Z'; + } else if (type == byte.class) { + return 'B'; + } else if (type == char.class) { + return 'C'; + } else if (type == short.class) { + return 'S'; + } else if (type == int.class) { + return 'I'; + } else if (type == long.class) { + return 'J'; + } else if (type == float.class) { + return 'F'; + } else if (type == double.class) { + return 'D'; + } + return 'V'; + } + + private static long rawBits(Object boxed) { + if (boxed instanceof Boolean) { + return ((Boolean) boxed) ? 1 : 0; + } else if (boxed instanceof Character) { + return (Character) boxed; + } else if (boxed instanceof Float) { + return Float.floatToRawIntBits((Float) boxed); + } else if (boxed instanceof Double) { + return Double.doubleToRawLongBits((Double) boxed); + } + return ((Number) boxed).longValue(); + } + + private static Object fromRawBits(Class type, long bits) { + if (type == boolean.class) { + return bits != 0; + } else if (type == byte.class) { + return (byte) bits; + } else if (type == char.class) { + return (char) bits; + } else if (type == short.class) { + return (short) bits; + } else if (type == int.class) { + return (int) bits; + } else if (type == long.class) { + return bits; + } else if (type == float.class) { + return Float.intBitsToFloat((int) bits); + } + return Double.longBitsToDouble(bits); + } + private static Object defaultPrimitiveValue(Class type) { if (type == boolean.class) { return Boolean.FALSE; From 2500a6bff632bfe2427c5c3f669b9b56f36cee13 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 03:09:48 -0300 Subject: [PATCH 02/16] fix(bindings): call JS implementations of interface default methods The class the runtime generates for new Interface({...}) and an anonymous Interface.extend({...}) stubs only the interface's abstract methods. A default method keeps its Java body, so a JS implementation of it is never called from Java. Library defaults only work when D8 desugars them into abstract methods, below minSdk 24; platform defaults never do. An interface whose methods are all default methods, such as a listener with no-op defaults, implemented through a namespace alias the static binding generator cannot see, does nothing at minSdk 24. When the implementation object defines any of the interface's default methods, the instance now gets a second generated class, named after the interface's class plus "-defaults", that also stubs every default method (API 24+, most specific declaration, no bridges). A per-instance long mask, written by native right after the constructor returns, has bit i set when the JS object has an own function, or an own accessor, named after the i-th of the interface's sorted default method names. A stub with its bit set calls JS like any other override; with it clear it runs the interface's Java body on the calling thread through the non-virtual call, never entering JS. A mask that was never written runs every Java body. An implementation object that defines no default method gets the class it gets today, and the per-new cost for an interface without default methods is one atomic load. The names come from Java once per interface per process and are published atomically on the shared MetadataNode; each runtime keeps its own strings for them. A class the static binding generator prebuilt for the interface still takes precedence. --- test-app/app/src/main/assets/app/mainpage.js | 1 + .../app/tests/defaultMethodOverridesWorker.js | 39 +++ .../testInterfaceDefaultMethodOverrides.js | 293 ++++++++++++++++++ .../com/tns/tests/DefaultMethodFixtures.java | 170 ++++++++++ .../contract/AllDefaultListener.java | 15 + .../java/com/tns/bindings/DefaultMethods.java | 128 ++++++++ .../src/main/java/com/tns/bindings/Dump.java | 89 ++++++ .../java/com/tns/bindings/ProxyGenerator.java | 11 +- .../runtime/src/main/cpp/CallbackHandlers.cpp | 59 +++- .../runtime/src/main/cpp/CallbackHandlers.h | 8 +- .../runtime/src/main/cpp/MetadataNode.cpp | 107 ++++++- test-app/runtime/src/main/cpp/MetadataNode.h | 25 ++ .../src/main/java/com/tns/DexFactory.java | 36 ++- .../src/main/java/com/tns/Runtime.java | 50 +++ .../com/tns/bindings/DefaultMethodsTest.java | 189 +++++++++++ 15 files changed, 1209 insertions(+), 11 deletions(-) create mode 100644 test-app/app/src/main/assets/app/tests/defaultMethodOverridesWorker.js create mode 100644 test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js create mode 100644 test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/AllDefaultListener.java create mode 100644 test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java create mode 100644 test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java diff --git a/test-app/app/src/main/assets/app/mainpage.js b/test-app/app/src/main/assets/app/mainpage.js index 6c8d5c2db..fc3012617 100644 --- a/test-app/app/src/main/assets/app/mainpage.js +++ b/test-app/app/src/main/assets/app/mainpage.js @@ -40,6 +40,7 @@ require("./tests/testWorkerResourceLimits"); require("./tests/testWorkerNestedConsole"); require("./tests/testMessaging"); require("./tests/testInterfaceDefaultMethods"); +require("./tests/testInterfaceDefaultMethodOverrides"); require("./tests/testInterfaceStaticMethods"); require("./tests/testMetadata"); require("./tests/testAsserts"); diff --git a/test-app/app/src/main/assets/app/tests/defaultMethodOverridesWorker.js b/test-app/app/src/main/assets/app/tests/defaultMethodOverridesWorker.js new file mode 100644 index 000000000..89df53ab4 --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/defaultMethodOverridesWorker.js @@ -0,0 +1,39 @@ +// Entry for testInterfaceDefaultMethodOverrides: implements interfaces through aliases, so +// this worker's runtime uses classes generated on the device. +var F = com.tns.tests.DefaultMethodFixtures; +var It = java.util.Iterator; +var Split = java.util.Spliterator; +var result = {}; + +try { + var removes = 0; + var withRemove = new It({ + hasNext: function () { return false; }, + next: function () { return null; }, + remove: function () { removes++; } + }); + result.newClassName = String(F.className(withRemove)); + result.remove = String(F.remove(withRemove)); + result.removes = removes; + + var withoutRemove = new It({ + hasNext: function () { return false; }, + next: function () { return null; }, + forEachRemaining: function () {} + }); + result.missingDefault = String(F.remove(withoutRemove)); + + var Sized = Split.extend({ + tryAdvance: function () { return false; }, + trySplit: function () { return null; }, + estimateSize: function () { return 7; }, + characteristics: function () { return Split.SIZED; }, + getExactSizeIfKnown: function () { return 7; } + }); + var sized = new Sized(); + result.extendClassName = String(F.className(sized)); + result.spliterator = String(F.spliteratorDefaults(sized)); +} catch (e) { + result.error = String(e && e.message || e); +} +postMessage(result); diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js new file mode 100644 index 000000000..946f320ab --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -0,0 +1,293 @@ +// The interfaces here are reached through aliases and never named in full in a `new` or +// `extend` call (except where a spec says otherwise), so the static binding generator does +// not prebuild their classes and the runtime generates them on the device. +describe("Interface default methods implemented in JS", function () { + var sdk = android.os.Build.VERSION.SDK_INT; + var F = com.tns.tests.DefaultMethodFixtures; + var SUFFIX = "-defaults"; + + var It = java.util.Iterator; + var Pred = java.util.function.Predicate; + var Split = java.util.Spliterator; + + function emptyIterator(members) { + var implementation = { + hasNext: function () { return false; }, + next: function () { return null; } + }; + for (var name in members) { + implementation[name] = members[name]; + } + return implementation; + } + + it("are called from Java on a class generated at runtime", function () { + if (sdk < 24) { + return; + } + var calls = []; + var it = new It(emptyIterator({ + remove: function () { calls.push("remove"); }, + forEachRemaining: function (consumer) { + calls.push("forEachRemaining"); + consumer.accept("js"); + } + })); + + expect(F.isRuntimeGenerated(it)).toBe(true); + expect(F.className(it)).toBe("com.tns.gen.java.util.Iterator" + SUFFIX); + expect(F.remove(it)).toBe("removed"); + expect(F.drain(it)).toBe("js"); + expect(calls).toEqual(["remove", "forEachRemaining"]); + }); + + it("pass arguments and return primitive and object results", function () { + if (sdk < 24) { + return; + } + var seenCharacteristics = []; + var spliterator = new Split({ + tryAdvance: function () { return false; }, + trySplit: function () { return null; }, + estimateSize: function () { return 3; }, + characteristics: function () { return Split.SIZED; }, + getExactSizeIfKnown: function () { return 42; }, + hasCharacteristics: function (characteristics) { + seenCharacteristics.push(characteristics); + return characteristics === Split.SORTED; + } + }); + expect(F.spliteratorDefaults(spliterator)).toBe("42|false|true"); + expect(seenCharacteristics).toEqual([Split.SIZED, Split.SORTED]); + + var negated = new Pred({ test: function (value) { return value === "no"; } }); + var andArguments = []; + var predicate = new Pred({ + test: function (value) { return value === "yes"; }, + negate: function () { return negated; }, + and: function (other) { + andArguments.push(other); + return other; + } + }); + expect(F.negate(predicate, "yes")).toBe("true|false"); + expect(F.negate(predicate, "no")).toBe("false|true"); + expect(F.and(predicate, negated, "no")).toBe("true"); + expect(andArguments.length).toBe(1); + expect(andArguments[0]).toBe(negated); + }); + + it("cover a default declared in a super-interface, an overloaded name and a narrowed return type", function () { + if (sdk < 24) { + return; + } + var OfInt = java.util.PrimitiveIterator.OfInt; + var calls = []; + var ofInt = new OfInt({ + hasNext: function () { return false; }, + nextInt: function () { return 0; }, + // Iterator's default + remove: function () { calls.push("remove"); }, + // forEachRemaining(IntConsumer) and forEachRemaining(Consumer) share the name + forEachRemaining: function () { calls.push("forEachRemaining"); }, + // Integer next() is a default narrowing Iterator's abstract Object next() + next: function () { + calls.push("next"); + return new java.lang.Integer(5); + } + }); + + expect(F.className(ofInt)).toBe("com.tns.gen.java.util.PrimitiveIterator_OfInt" + SUFFIX); + expect(F.remove(ofInt)).toBe("removed"); + expect(F.drainInts(ofInt)).toBe(""); + expect(F.drain(ofInt)).toBe(""); + expect(F.next(ofInt)).toBe("5"); + expect(calls).toEqual(["remove", "forEachRemaining", "forEachRemaining", "next"]); + }); + + it("leave the defaults the JS object lacks to their Java bodies, on the same instance", function () { + if (sdk < 24) { + return; + } + var drains = 0; + var it = new It(emptyIterator({ + forEachRemaining: function () { drains++; } + })); + + expect(F.className(it)).toBe("com.tns.gen.java.util.Iterator" + SUFFIX); + // Iterator.remove() throws this itself, so it arrives with its own type. + expect(F.remove(it)).toBe("java.lang.UnsupportedOperationException"); + F.drain(it); + expect(drains).toBe(1); + }); + + it("run a missing default on the calling thread without the JS thread", function () { + if (sdk < 24) { + return; + } + var drains = 0; + var removes = 0; + var it = new It(emptyIterator({ + forEachRemaining: function () { drains++; } + })); + // This thread waits inside the fixture, so a call that needed it would time out. + expect(F.removeOnBackgroundThread(it, 5000)).toBe(F.CALLER_THREAD + "|java.lang.UnsupportedOperationException|true"); + expect(drains).toBe(0); + + var withRemove = new It(emptyIterator({ + remove: function () { removes++; } + })); + expect(F.removeOnBackgroundThread(withRemove, 300)).toBe("timeout"); + }, 15000); + + it("keep the class an instance gets today when its JS object defines no default method", function () { + if (sdk < 24) { + return; + } + var IntPred = java.util.function.IntPredicate; + var predicate = new IntPred({ test: function (value) { return value > 0; } }); + + expect(F.className(predicate)).toBe("com.tns.gen.java.util.function.IntPredicate"); + expect(F.isClassLoaded("com.tns.gen.java.util.function.IntPredicate" + SUFFIX, predicate)).toBe(false); + expect(F.intNegate(predicate, 1)).toBe("true|false"); + + var plain = new Pred({ test: function () { return true; } }); + var overriding = new Pred({ + test: function () { return true; }, + negate: function () { return plain; } + }); + expect(F.className(plain)).toBe("com.tns.gen.java.util.function.Predicate"); + expect(F.className(overriding)).toBe("com.tns.gen.java.util.function.Predicate" + SUFFIX); + expect(F.negate(plain, "x")).toBe("true|false"); + expect(F.negate(overriding, "x")).toBe("true|true"); + }); + + it("count an own function or accessor as an implementation, and nothing else", function () { + if (sdk < 24) { + return; + } + var notAFunction = new It(emptyIterator({ remove: 42 })); + expect(F.className(notAFunction)).toBe("com.tns.gen.java.util.Iterator"); + expect(F.remove(notAFunction)).toBe("java.lang.UnsupportedOperationException"); + + var getterCalls = 0; + var removes = 0; + var withAccessor = emptyIterator({}); + Object.defineProperty(withAccessor, "remove", { + get: function () { + getterCalls++; + return function () { removes++; }; + } + }); + var viaAccessor = new It(withAccessor); + expect(getterCalls).toBe(0); + expect(F.className(viaAccessor)).toBe("com.tns.gen.java.util.Iterator" + SUFFIX); + expect(F.remove(viaAccessor)).toBe("removed"); + expect(getterCalls).toBe(1); + expect(removes).toBe(1); + + // Read at call time like any JS implementation: a getter returning something else + // fails that call, as an abstract method's non-function implementation does. + var withBadAccessor = emptyIterator({}); + Object.defineProperty(withBadAccessor, "remove", { + get: function () { return 42; } + }); + expect(F.remove(new It(withBadAccessor))).toBe("com.tns.NativeScriptException"); + }); + + it("are called through a class from extend()", function () { + if (sdk < 24) { + return; + } + var LongPred = java.util.function.LongPredicate; + var negations = 0; + var Positive = LongPred.extend({ + test: function (value) { return value > 0; }, + negate: function () { + negations++; + return new LongPred({ test: function () { return true; } }); + } + }); + var first = new Positive(); + var second = new Positive(); + + expect(F.className(first)).toBe("com.tns.gen.java.util.function.LongPredicate" + SUFFIX); + expect(F.longNegate(first, 5)).toBe("true|true"); + expect(F.longNegate(second, -5)).toBe("false|true"); + expect(negations).toBe(2); + }); + + it("are called from Java in a worker", function (done) { + if (sdk < 24) { + done(); + return; + } + var worker = new Worker("./defaultMethodOverridesWorker.js"); + worker.onmessage = function (msg) { + worker.terminate(); + expect(msg.data.error).toBeUndefined(); + expect(msg.data.newClassName).toBe("com.tns.gen.java.util.Iterator" + SUFFIX); + expect(msg.data.remove).toBe("removed"); + expect(msg.data.removes).toBe(1); + expect(msg.data.missingDefault).toBe("java.lang.UnsupportedOperationException"); + expect(msg.data.extendClassName).toBe("com.tns.gen.java.util.Spliterator" + SUFFIX); + expect(msg.data.spliterator).toBe("7|true|false"); + done(); + }; + }, 15000); + + it("leave a prebuilt class of the interface in charge", function () { + if (sdk < 24) { + return; + } + // Full name: the static binding generator prebuilds this interface's class with + // the methods this call site lists. + var prebuiltRemoves = 0; + var prebuilt = new java.util.PrimitiveIterator.OfLong({ + hasNext: function () { return false; }, + nextLong: function () { return 0; }, + remove: function () { prebuiltRemoves++; } + }); + expect(F.isRuntimeGenerated(prebuilt)).toBe(false); + expect(F.remove(prebuilt)).toBe("removed"); + expect(prebuiltRemoves).toBe(1); + + var OfLong = java.util.PrimitiveIterator.OfLong; + var aliasedRemoves = 0; + var aliased = new OfLong({ + hasNext: function () { return false; }, + nextLong: function () { return 0; }, + remove: function () { aliasedRemoves++; } + }); + expect(F.className(aliased)).toBe(F.className(prebuilt)); + expect(F.remove(aliased)).toBe("removed"); + expect(aliasedRemoves).toBe(1); + }); + + it("reach JS for an interface whose methods are all default methods, unless D8 desugared them", function () { + if (sdk < 24) { + return; + } + var L = com.tns.tests.interfaces.defaultmethods.contract.AllDefaultListener; + var calls = []; + var listener = new L({ + onText: function (text) { calls.push("text:" + text); }, + describe: function () { return "js describe"; } + }); + + if (F.isDesugared()) { + // Below minSdk 24 the methods are abstract on the device: every one reaches JS, + // and one the JS object lacks has no Java body to fall back to. + expect(F.fire(listener)).toBe("com.tns.NativeScriptException"); + expect(calls).toEqual(["text:a"]); + return; + } + + expect(F.className(listener)).toBe("com.tns.gen.com.tns.tests.interfaces.defaultmethods.contract.AllDefaultListener" + SUFFIX); + expect(F.fire(listener)).toBe("js describe"); + expect(calls).toEqual(["text:a"]); + + var onlyText = new L({ onText: function () {} }); + expect(F.describeOnBackgroundThread(onlyText, 5000)).toBe("java default on " + F.CALLER_THREAD); + }, 15000); +}); diff --git a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java new file mode 100644 index 000000000..400e99793 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -0,0 +1,170 @@ +package com.tns.tests; + +import com.tns.tests.interfaces.defaultmethods.contract.AllDefaultListener; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.PrimitiveIterator; +import java.util.Spliterator; +import java.util.function.Consumer; +import java.util.function.IntConsumer; +import java.util.function.IntPredicate; +import java.util.function.LongPredicate; +import java.util.function.Predicate; + +// Java callers of interface default methods for testInterfaceDefaultMethodOverrides.js. Uses +// API 24 types, so specs touch it only on API 24+. +public class DefaultMethodFixtures { + public static final String CALLER_THREAD = "default-method-caller"; + + // Only classes the runtime generates on the device declare this field; the static + // binding generator's classes do not. + public static boolean isRuntimeGenerated(Object instance) { + try { + instance.getClass().getDeclaredField("__initialized"); + return true; + } catch (NoSuchFieldException e) { + return false; + } + } + + public static String className(Object instance) { + return instance.getClass().getName(); + } + + public static boolean isClassLoaded(String name, Object anyAppObject) { + try { + Class.forName(name, false, anyAppObject.getClass().getClassLoader()); + return true; + } catch (ClassNotFoundException e) { + return false; + } + } + + public static String remove(Iterator it) { + try { + it.remove(); + return "removed"; + } catch (Throwable t) { + return t.getClass().getName(); + } + } + + public static String next(Iterator it) { + try { + return java.util.Objects.toString(it.next()); + } catch (Throwable t) { + return t.getClass().getName(); + } + } + + public static String drain(Iterator it) { + final List seen = new ArrayList<>(); + it.forEachRemaining(new Consumer() { + @Override + public void accept(Object item) { + seen.add(java.util.Objects.toString(item)); + } + }); + return android.text.TextUtils.join(",", seen); + } + + public static String drainInts(PrimitiveIterator.OfInt it) { + final StringBuilder seen = new StringBuilder(); + it.forEachRemaining(new IntConsumer() { + @Override + public void accept(int value) { + if (seen.length() > 0) { + seen.append(','); + } + seen.append(value); + } + }); + return seen.toString(); + } + + @SuppressWarnings("unchecked") + public static String negate(Predicate p, Object value) { + Predicate predicate = (Predicate) p; + return predicate.test(value) + "|" + predicate.negate().test(value); + } + + @SuppressWarnings("unchecked") + public static String and(Predicate p, Predicate other, Object value) { + return Boolean.toString(((Predicate) p).and((Predicate) other).test(value)); + } + + public static String intNegate(IntPredicate p, int value) { + return p.test(value) + "|" + p.negate().test(value); + } + + public static String longNegate(LongPredicate p, long value) { + return p.test(value) + "|" + p.negate().test(value); + } + + public static String spliteratorDefaults(Spliterator spliterator) { + return spliterator.getExactSizeIfKnown() + "|" + spliterator.hasCharacteristics(Spliterator.SIZED) + + "|" + spliterator.hasCharacteristics(Spliterator.SORTED); + } + + public static String fire(AllDefaultListener listener) { + try { + listener.onText("a"); + listener.onNumber(7); + return listener.describe(); + } catch (Throwable t) { + return t.getClass().getName(); + } + } + + public static boolean isDesugared() throws NoSuchMethodException { + return !AllDefaultListener.class.getMethod("describe").isDefault(); + } + + /* + * Calls it.remove() on a new thread while the calling (JS) thread waits here, so a + * call that needed the JS thread could not complete before the timeout. Reports the + * thread the exception was thrown on, its type, and whether Iterator's own body threw it. + */ + public static String removeOnBackgroundThread(final Iterator it, long timeoutMillis) throws InterruptedException { + final String[] result = new String[1]; + Thread caller = new Thread(new Runnable() { + @Override + public void run() { + try { + it.remove(); + result[0] = Thread.currentThread().getName() + "|removed"; + } catch (Throwable t) { + boolean fromIteratorBody = false; + for (StackTraceElement frame : t.getStackTrace()) { + if (frame.getClassName().equals("java.util.Iterator") && frame.getMethodName().equals("remove")) { + fromIteratorBody = true; + } + } + result[0] = Thread.currentThread().getName() + "|" + t.getClass().getName() + "|" + fromIteratorBody; + } + } + }, CALLER_THREAD); + caller.start(); + caller.join(timeoutMillis); + return caller.isAlive() ? "timeout" : result[0]; + } + + public static String describeOnBackgroundThread(final AllDefaultListener listener, long timeoutMillis) throws InterruptedException { + final String[] result = new String[1]; + Thread caller = new Thread(new Runnable() { + @Override + public void run() { + try { + result[0] = listener.describe(); + } catch (Throwable t) { + result[0] = t.getClass().getName(); + } + } + }, CALLER_THREAD); + caller.start(); + caller.join(timeoutMillis); + return caller.isAlive() ? "timeout" : result[0]; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/AllDefaultListener.java b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/AllDefaultListener.java new file mode 100644 index 000000000..397912a5c --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/AllDefaultListener.java @@ -0,0 +1,15 @@ +package com.tns.tests.interfaces.defaultmethods.contract; + +// Every method is a default method. The app module is dexed for the app's minSdk, so below 24 +// D8 turns these into abstract methods; at 24 and above they stay default methods. +public interface AllDefaultListener { + default void onText(String text) { + } + + default void onNumber(int number) { + } + + default String describe() { + return "java default on " + Thread.currentThread().getName(); + } +} 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 new file mode 100644 index 000000000..948336424 --- /dev/null +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java @@ -0,0 +1,128 @@ +package com.tns.bindings; + +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; + +/** + * The default methods a class implementing an interface inherits, and the bit each one's + * name gets in the per-instance mask of the class generated to dispatch them to JS. Both + * sides derive the bits from the interface alone. Method.isDefault() needs API 24. + */ +public final class DefaultMethods { + /** Names past this many keep their Java bodies: the mask is a long. */ + public static final int MAX_DISPATCHED_NAMES = 64; + + private DefaultMethods() { + } + + /** + * The most specific declaration of every method signature of the interface's hierarchy + * that is a default method, sorted by name and then by key. Bridges are left out: they + * forward to the method they bridge. + */ + public static List collect(Class iface) { + return collect(Collections.>singletonList(iface), Collections.emptySet()); + } + + private static String signature(Method method) { + return method.getName() + Arrays.toString(method.getParameterTypes()); + } + + private static List collect(Collection> roots, Set excludedSignatures) { + Map> declarationsBySignature = new LinkedHashMap<>(); + Set> visited = new HashSet<>(); + Deque> pending = new ArrayDeque<>(roots); + while (!pending.isEmpty()) { + Class current = pending.poll(); + if (!visited.add(current)) { + continue; + } + for (Method method : current.getDeclaredMethods()) { + int modifiers = method.getModifiers(); + if (Modifier.isStatic(modifiers) || !Modifier.isPublic(modifiers) || method.isSynthetic() || method.isBridge()) { + continue; + } + String signature = signature(method); + if (excludedSignatures.contains(signature)) { + continue; + } + List declarations = declarationsBySignature.get(signature); + if (declarations == null) { + declarations = new ArrayList<>(); + declarationsBySignature.put(signature, declarations); + } + declarations.add(method); + } + pending.addAll(Arrays.asList(current.getInterfaces())); + } + + List result = new ArrayList<>(); + for (List declarations : declarationsBySignature.values()) { + Method mostSpecific = null; + int maximal = 0; + for (Method candidate : declarations) { + boolean overridden = false; + for (Method other : declarations) { + if (other != candidate && candidate.getDeclaringClass() != other.getDeclaringClass() + && candidate.getDeclaringClass().isAssignableFrom(other.getDeclaringClass())) { + overridden = true; + break; + } + } + if (!overridden) { + mostSpecific = candidate; + maximal++; + } + } + // Several maximal declarations conflict, and the class must override them + // itself; that case keeps whatever it does without this class. + if (maximal == 1 && mostSpecific.isDefault()) { + result.add(mostSpecific); + } + } + + Collections.sort(result, new Comparator() { + @Override + public int compare(Method a, Method b) { + int byName = a.getName().compareTo(b.getName()); + return byName != 0 ? byName : key(a).compareTo(key(b)); + } + }); + return result; + } + + /** Sorted distinct names of {@link #collect}; a name's index is its bit. */ + public static String[] names(Class iface) { + TreeSet names = new TreeSet<>(); + for (Method method : collect(iface)) { + names.add(method.getName()); + } + return names.toArray(new String[0]); + } + + /** Identifies a default method to com.tns.Runtime.callInterfaceDefault. */ + public static String key(Method method) { + StringBuilder key = new StringBuilder(method.getDeclaringClass().getName()).append('.').append(method.getName()).append('('); + Class[] parameterTypes = method.getParameterTypes(); + for (int i = 0; i < parameterTypes.length; i++) { + if (i > 0) { + key.append(','); + } + key.append(parameterTypes[i].getName()); + } + return key.append(')').append(method.getReturnType().getName()).toString(); + } +} 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 79d959b23..8cdfc980a 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 @@ -26,6 +26,19 @@ public class Dump { static final String RUNTIME_TAG_FIELD_NAME = "runtimeTag__ns"; static final String OBJECT_ID_FIELD_NAME = "objectId__ns"; + /* + * Names the class of an interface implementation that also stubs the interface's + * default methods. A '-' cannot come from Java source, so no static binding generator + * class has it, and a nested interface's '$' becomes '_' instead. MetadataNode.cpp + * spells the same suffix. + */ + public static final String DEFAULT_OVERRIDING_SUFFIX = "-defaults"; + // Bit i: the JS object implements the i-th of DefaultMethods.names. Native writes it + // after the constructor returns; zero runs every default's Java body. + static final String DEFAULT_OVERRIDES_FIELD_NAME = "defaultOverrides__ns"; + static final String callInterfaceDefaultMethodName = "callInterfaceDefault"; + private static final String callInterfaceDefaultSignature = "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Object;"; + /** * Returns the dex descriptor corresponding to the given method. * @@ -162,6 +175,15 @@ private static String getClassSignatureOfType(final ClassDescriptor c) { } public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescriptor classTo, HashSet methodOverrides, HashSet implementedInterfaces, AnnotationDescriptor[] annotations) { + generateProxy(aw, proxyName, classTo, methodOverrides, implementedInterfaces, annotations, null); + } + + /** + * defaultMethods, for an anonymous interface implementation, are the interface's + * DefaultMethods.collect: the class gets the DEFAULT_OVERRIDING_SUFFIX name and a stub + * for each of them as well. null generates the class without them. + */ + public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescriptor classTo, HashSet methodOverrides, HashSet implementedInterfaces, AnnotationDescriptor[] annotations, List defaultMethods) { String classSignature = getAsmDescriptor(classTo); String tnsClassSignature; @@ -173,6 +195,8 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto if (!classTo.isInterface()) { tnsClassSignature += CLASS_NAME_LOCATION_SEPARATOR + proxyName; + } else if (defaultMethods != null) { + tnsClassSignature += DEFAULT_OVERRIDING_SUFFIX; } tnsClassSignature += ";"; @@ -184,6 +208,10 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto methods = groupMethodsByNameAndSignature(methods); generateFields(cv); + if (defaultMethods != null) { + FieldVisitor fv = cv.visitField(org.ow2.asmdex.Opcodes.ACC_PRIVATE | org.ow2.asmdex.Opcodes.ACC_VOLATILE, DEFAULT_OVERRIDES_FIELD_NAME, "J", null, null); + fv.visitEnd(); + } MethodDescriptor[] ctors = classTo.getConstructors(); @@ -192,9 +220,70 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto generateMethods(cv, classTo, methods, classSignature, tnsClassSignature); + if (defaultMethods != null) { + generateDefaultMethodStubs(cv, defaultMethods, methods, classSignature, tnsClassSignature); + } + cv.visitEnd(); } + private void generateDefaultMethodStubs(ClassVisitor cv, List defaultMethods, MethodDescriptor[] generatedMethods, String classSignature, String tnsClassSignature) { + Set generatedSignatures = new HashSet(); + for (MethodDescriptor generated : generatedMethods) { + generatedSignatures.add(generated.getName() + "_" + getMethodOverloadDescriptor(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))) { + continue; + } + generateDefaultMethodStub(cv, defaultMethod, method, bit, classSignature, tnsClassSignature); + } + } + + private static List namesOf(List methods) { + List names = new ArrayList(); + for (java.lang.reflect.Method method : methods) { + names.add(method.getName()); + } + return names; + } + + /* + * Calls JS when the instance's mask has the bit of the method's name, and otherwise + * runs the interface's body through Runtime.callInterfaceDefault, on the calling thread. + */ + private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method defaultMethod, MethodDescriptor method, int bit, String classSignature, String tnsClassSignature) { + MethodVisitor mv = cv.visitMethod(org.ow2.asmdex.Opcodes.ACC_PUBLIC, method.getName(), getDexMethodDescriptor(method), null, new String[0]); + mv.visitCode(); + + int thisRegister = generateMaxStackSize(mv, method); + + // v0-v1 hold the mask, v2 the shift + mv.visitFieldInsn(org.ow2.asmdex.Opcodes.INSN_IGET_WIDE, tnsClassSignature, DEFAULT_OVERRIDES_FIELD_NAME, "J", 0, thisRegister); + mv.visitVarInsn(org.ow2.asmdex.Opcodes.INSN_CONST_16, 2, bit); + mv.visitOperationInsn(org.ow2.asmdex.Opcodes.INSN_USHR_LONG, 0, 0, 2, 0); + mv.visitOperationInsn(org.ow2.asmdex.Opcodes.INSN_LONG_TO_INT, 0, 0, 0, 0); + mv.visitOperationInsn(org.ow2.asmdex.Opcodes.INSN_AND_INT_LIT8, 0, 0, 0, 1); + Label javaBody = new Label(); + mv.visitJumpInsn(org.ow2.asmdex.Opcodes.INSN_IF_EQZ, javaBody, 0, 0); + + generateCallOverrideBlock(mv, method, thisRegister, classSignature, tnsClassSignature); + generateReturnFromObject(mv, method.getReturnType(), thisRegister, 1); + + mv.visitLabel(javaBody); + generateArrayForCallJsArguments(mv, method.getParameterTypes(), thisRegister, classSignature, tnsClassSignature); + mv.visitStringInsn(org.ow2.asmdex.Opcodes.INSN_CONST_STRING, 1, DefaultMethods.key(defaultMethod)); + mv.visitTypeInsn(org.ow2.asmdex.Opcodes.INSN_CONST_CLASS, 2, 0, 0, getAsmDescriptor(new ClassInfo(defaultMethod.getDeclaringClass()))); + mv.visitMethodInsn(org.ow2.asmdex.Opcodes.INSN_INVOKE_STATIC, runtimeClass, callInterfaceDefaultMethodName, callInterfaceDefaultSignature, new int[] { thisRegister, 2, 1, 0 }); + generateReturnFromObject(mv, method.getReturnType(), thisRegister, 1); + + mv.visitEnd(); + } + private MethodDescriptor[] groupMethodsByNameAndSignature(MethodDescriptor[] methods) { HashMap result = new HashMap(); for (int i = 0; i < methods.length; i++) { diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java index 1cbfc8b0f..1fc1e83a4 100644 --- a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java @@ -3,7 +3,9 @@ import java.io.File; import java.io.FileOutputStream; import java.io.IOException; +import java.lang.reflect.Method; import java.util.HashSet; +import java.util.List; import org.ow2.asmdex.ApplicationWriter; @@ -37,10 +39,15 @@ public String generateProxy(String proxyName, ClassDescriptor classToProxy, Hash * loading the previous dex. */ public String generateProxy(String proxyName, String cacheDigest, ClassDescriptor classToProxy, HashSet methodOverrides, HashSet implementedInterfaces, boolean isInterface, AnnotationDescriptor[] annotations) throws IOException { + return generateProxy(proxyName, cacheDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, annotations, null); + } + + /** defaultMethods: see Dump.generateProxy. */ + public String generateProxy(String proxyName, String cacheDigest, ClassDescriptor classToProxy, HashSet methodOverrides, HashSet implementedInterfaces, boolean isInterface, AnnotationDescriptor[] annotations, List defaultMethods) throws IOException { ApplicationWriter aw = new ApplicationWriter(); aw.visit(); - dump.generateProxy(aw, proxyName, classToProxy, methodOverrides, implementedInterfaces, annotations); + dump.generateProxy(aw, proxyName, classToProxy, methodOverrides, implementedInterfaces, annotations, defaultMethods); aw.visitEnd(); byte[] generatedBytes = aw.toByteArray(); @@ -60,6 +67,8 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto proxyFileName = classToProxy.getName().replace('$', '_'); if (!isInterface) { proxyFileName += Dump.CLASS_NAME_LOCATION_SEPARATOR + proxyName; + } else if (defaultMethods != null) { + proxyFileName += Dump.DEFAULT_OVERRIDING_SUFFIX; } if (proxyThumb != null) { proxyFileName += "-" + proxyThumb; diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp index 92dd9afb4..594cf849d 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp @@ -67,6 +67,10 @@ void CallbackHandlers::Init(Isolate *isolate) { "(Ljava/lang/String;I)[Ljava/lang/String;"); NS_CHECK(GET_TYPE_METADATA != nullptr); + GET_DEFAULT_METHOD_NAMES = env.GetStaticMethodID(RUNTIME_CLASS, "getDefaultMethodNames", + "(Ljava/lang/String;)[Ljava/lang/String;"); + NS_CHECK(GET_DEFAULT_METHOD_NAMES != nullptr); + ENABLE_VERBOSE_LOGGING_METHOD_ID = env.GetMethodID(RUNTIME_CLASS, "enableVerboseLogging", "()V"); NS_CHECK(ENABLE_VERBOSE_LOGGING_METHOD_ID != nullptr); @@ -136,12 +140,59 @@ class CallbackHandlers::ConstructionScope { Runtime::Construction _previous; }; +namespace { +/* + * A prebuilt class of the interface, used instead of the default-overriding class when the + * app has one, lacks the field and keeps its own behaviour. The class cache hands out one + * global reference per class name for the life of the process, so it is a stable key. + */ +void SetDefaultOverrides(JNIEnv* env, jobject instance, jclass clazz, uint64_t defaultOverrides) { + thread_local robin_hood::unordered_map fields; + + jfieldID field; + auto found = fields.find(clazz); + if (found != fields.end()) { + field = found->second; + } else { + field = env->GetFieldID(clazz, "defaultOverrides__ns", "J"); + if (field == nullptr) { + env->ExceptionClear(); + } + fields.emplace(clazz, field); + } + + if (field != nullptr) { + env->SetLongField(instance, field, static_cast(defaultOverrides)); + } +} +} // namespace + +std::vector CallbackHandlers::GetDefaultMethodNames(const std::string &interfaceName) { + JEnv env; + + JniLocalRef className(env.NewStringUTF(Util::ConvertFromJniToCanonicalName(interfaceName).c_str())); + JniLocalRef names(env.CallStaticObjectMethod(RUNTIME_CLASS, GET_DEFAULT_METHOD_NAMES, (jstring) className)); + + std::vector result; + if (names.IsNull()) { + return result; + } + + jsize length = env.GetArrayLength(names); + for (jsize i = 0; i < length; i++) { + JniLocalRef name(env.GetObjectArrayElement(names, i)); + result.push_back(ArgConverter::jstringToString((jstring) name)); + } + return result; +} + bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &jsObject, const std::string &fullClassName, const ArgsWrapper &argWrapper, const Local &implementationObject, bool isInterface, - const std::string &baseClassName) { + const std::string &baseClassName, + uint64_t defaultOverrides) { bool success; DEBUG_WRITE("RegisterInstance called for '%s'", fullClassName.c_str()); @@ -182,6 +233,11 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &j } } + // Before any Java code but the constructor's own can see the instance. + if (defaultOverrides != 0 && instance != nullptr) { + SetDefaultOverrides(env, instance, generatedJavaClass, defaultOverrides); + } + jlong usedJavaMemory = env.CallLongMethod(runtime->GetJavaRuntime(), REGISTER_CONSTRUCTED_INSTANCE_ID, instance, javaObjectID); @@ -2016,6 +2072,7 @@ jfieldID CallbackHandlers::CURRENT_OBJECTCLASS_FIELD_ID = nullptr; jmethodID CallbackHandlers::RESOLVE_CLASS_METHOD_ID = nullptr; jmethodID CallbackHandlers::REGISTER_CONSTRUCTED_INSTANCE_ID = nullptr; jmethodID CallbackHandlers::GET_TYPE_METADATA = nullptr; +jmethodID CallbackHandlers::GET_DEFAULT_METHOD_NAMES = nullptr; jmethodID CallbackHandlers::ENABLE_VERBOSE_LOGGING_METHOD_ID = nullptr; jmethodID CallbackHandlers::DISABLE_VERBOSE_LOGGING_METHOD_ID = nullptr; diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.h b/test-app/runtime/src/main/cpp/CallbackHandlers.h index 43f040dd9..4d0eb56e9 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.h +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.h @@ -40,7 +40,11 @@ namespace tns { const ArgsWrapper &argWrapper, const v8::Local &implementationObject, bool isInterface, - const std::string &baseClassName = std::string()); + const std::string &baseClassName = std::string(), + uint64_t defaultOverrides = 0); + + // com.tns.Runtime.getDefaultMethodNames of the interface. + static std::vector GetDefaultMethodNames(const std::string &interfaceName); static jclass ResolveClass(v8::Isolate *isolate, const std::string &baseClassName, const std::string &fullClassName, @@ -199,6 +203,8 @@ namespace tns { static jmethodID GET_TYPE_METADATA; + static jmethodID GET_DEFAULT_METHOD_NAMES; + static jmethodID ENABLE_VERBOSE_LOGGING_METHOD_ID; static jmethodID DISABLE_VERBOSE_LOGGING_METHOD_ID; diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp index c8f9b84ba..4b5c58496 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.cpp +++ b/test-app/runtime/src/main/cpp/MetadataNode.cpp @@ -1401,7 +1401,7 @@ void MetadataNode::ExtendedClassConstructorCallback(const v8::FunctionCallbackIn string fullClassName = extData->fullClassName; - bool success = CallbackHandlers::RegisterInstance(isolate, thiz, fullClassName, argWrapper, implementationObject, false, extData->node->m_name); + bool success = CallbackHandlers::RegisterInstance(isolate, thiz, fullClassName, argWrapper, implementationObject, false, extData->node->m_name, extData->defaultOverrides); } catch (NativeScriptException& e) { e.ReThrowToV8(); } catch (std::exception e) { @@ -1454,6 +1454,10 @@ void MetadataNode::InterfaceConstructorCallback(const v8::FunctionCallbackInfom_implType; + uint64_t defaultOverrides = node->GetDefaultOverrides(isolate, implementationObject); + if (defaultOverrides != 0) { + className += DEFAULT_OVERRIDING_SUFFIX; + } SetInstanceMetadata(isolate, thiz, node); //@@@ Refactor @@ -1465,7 +1469,7 @@ void MetadataNode::InterfaceConstructorCallback(const v8::FunctionCallbackInfom_name); @@ -2020,9 +2024,26 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfom_treeNode); bool isInterface = s_metadataReader.IsNodeTypeInterface(nodeType); - auto clazz = CallbackHandlers::ResolveClass(isolate, baseClassName, fullClassName, implementationObject, isInterface); + // Every instance of the extend shares its implementation object, and so its mask. + uint64_t defaultOverrides = 0; + if (isInterface && !hasDot) { + auto interfacesKey = String::NewFromUtf8Literal(isolate, "interfaces"); + if (!implementationObject->Has(isolate->GetCurrentContext(), interfacesKey).FromMaybe(true)) { + defaultOverrides = node->GetDefaultOverrides(isolate, implementationObject); + } + } + auto clazz = defaultOverrides != 0 + ? CallbackHandlers::ResolveClass(isolate, string(), node->m_implType + DEFAULT_OVERRIDING_SUFFIX, implementationObject, isInterface) + : CallbackHandlers::ResolveClass(isolate, baseClassName, fullClassName, implementationObject, isInterface); auto fullExtendedName = CallbackHandlers::ResolveClassName(isolate, clazz); DEBUG_WRITE("ExtendsCallMethodHandler: extend full name %s", fullClassName.c_str()); + if (defaultOverrides != 0) { + // The constructor resolves the class by its own name, which differs from the + // requested one for a nested interface ('$' became '_'). + JEnv env; + auto localClass = static_cast(env.NewLocalRef(clazz)); + env.InsertClassIntoCache(fullExtendedName, localClass); + } auto cachedData = GetCachedExtendedClassData(isolate, fullExtendedName); if (cachedData.extendedCtorFunction != nullptr) { @@ -2048,7 +2069,9 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfoGetConstructorFunction(isolate); - auto extendData = External::New(isolate, cache->Own(node, extendNameAndLocation, implementationObject, fullExtendedName), v8::kExternalPointerTypeTagDefault); + auto extendedClassCallbackData = cache->Own(node, extendNameAndLocation, implementationObject, fullExtendedName); + extendedClassCallbackData->defaultOverrides = defaultOverrides; + auto extendData = External::New(isolate, extendedClassCallbackData, v8::kExternalPointerTypeTagDefault); auto extendFuncTemplate = FunctionTemplate::New(isolate, ExtendedClassConstructorCallback, extendData); extendFuncTemplate->InstanceTemplate()->SetInternalFieldCount(static_cast(ObjectManager::MetadataNodeKeys::END)); @@ -2565,6 +2588,82 @@ std::string MetadataNode::GetJniClassName(MetadataEntry& entry) { return fullClassName; } +const MetadataNode::DefaultMethodNames* MetadataNode::LoadDefaultMethodNames() { + static const DefaultMethodNames none; + + const DefaultMethodNames* loaded = &none; + auto names = CallbackHandlers::GetDefaultMethodNames(m_name); + if (!names.empty()) { + if (names.size() > 64) { + names.resize(64); + } + loaded = new DefaultMethodNames{std::move(names)}; + } + + const DefaultMethodNames* published = nullptr; + if (!m_defaultMethodNames.compare_exchange_strong(published, loaded, std::memory_order_acq_rel, std::memory_order_acquire)) { + if (loaded != &none) { + delete loaded; + } + return published; + } + return loaded; +} + +uint64_t MetadataNode::GetDefaultOverrides(Isolate* isolate, const Local& implementationObject) { + auto defaults = m_defaultMethodNames.load(std::memory_order_acquire); + if (defaults == nullptr) { + defaults = LoadDefaultMethodNames(); + } + if (defaults->names.empty()) { + return 0; + } + + auto& keys = GetMetadataNodeCache(isolate)->DefaultMethodNameKeys[this]; + if (keys.empty()) { + keys.reserve(defaults->names.size()); + for (const auto& name : defaults->names) { + keys.emplace_back(isolate, String::NewFromUtf8(isolate, name.c_str(), NewStringType::kInternalized).ToLocalChecked()); + } + } + + auto context = isolate->GetCurrentContext(); + TryCatch tc(isolate); + uint64_t mask = 0; + Local getKey; + Local setKey; + Local valueKey; + for (size_t bit = 0; bit < keys.size(); bit++) { + auto key = keys[bit].Get(isolate); + if (!implementationObject->HasOwnProperty(context, key).FromMaybe(false)) { + continue; + } + + Local descriptor; + if (!implementationObject->GetOwnPropertyDescriptor(context, key).ToLocal(&descriptor) || !descriptor->IsObject()) { + continue; + } + if (getKey.IsEmpty()) { + getKey = String::NewFromUtf8Literal(isolate, "get"); + setKey = String::NewFromUtf8Literal(isolate, "set"); + valueKey = String::NewFromUtf8Literal(isolate, "value"); + } + auto fields = descriptor.As(); + Local value; + bool isAccessor = fields->HasOwnProperty(context, getKey).FromMaybe(false) || fields->HasOwnProperty(context, setKey).FromMaybe(false); + if (isAccessor || (fields->Get(context, valueKey).ToLocal(&value) && value->IsFunction())) { + mask |= uint64_t{1} << bit; + } + } + + // Only a Proxy implementation object can throw here, from one of its traps. + if (tc.HasCaught()) { + throw NativeScriptException(tc, "Could not read the properties of the implementation object"); + } + return mask; +} + +const char* const MetadataNode::DEFAULT_OVERRIDING_SUFFIX = "-defaults"; string MetadataNode::TNS_PREFIX = "com/tns/gen/"; MetadataReader MetadataNode::s_metadataReader; robin_hood::unordered_map MetadataNode::s_name2NodeCache; diff --git a/test-app/runtime/src/main/cpp/MetadataNode.h b/test-app/runtime/src/main/cpp/MetadataNode.h index 6437b9932..6f0bf703b 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.h +++ b/test-app/runtime/src/main/cpp/MetadataNode.h @@ -78,7 +78,26 @@ class MetadataNode { static MetadataReader* getMetadataReader() { return &s_metadataReader; } + + /* + * The mask of an instance of this interface's DEFAULT_OVERRIDING_SUFFIX class: bit i + * is set when the implementation object has an own property named the i-th of the + * interface's default method names (com.tns.Runtime.getDefaultMethodNames) that a call + * would invoke, i.e. a data property holding a function, or an accessor, which is not + * run here. 0, after one atomic load, for an interface without default methods. + */ + uint64_t GetDefaultOverrides(v8::Isolate* isolate, const v8::Local& implementationObject); + + // com.tns.bindings.Dump.DEFAULT_OVERRIDING_SUFFIX + static const char* const DEFAULT_OVERRIDING_SUFFIX; private: + // Index i is bit i of an instance's mask. + struct DefaultMethodNames { + std::vector names; + }; + + const DefaultMethodNames* LoadDefaultMethodNames(); + struct MethodCallbackData; struct ExtendedClassCallbackData; @@ -199,6 +218,8 @@ class MetadataNode { bool m_isArray; // Read on every Java method call; GetNodeType takes the reader's state lock. bool m_isInterface; + // Published once, never freed: nodes are shared by every isolate in the process. + std::atomic m_defaultMethodNames{nullptr}; static std::string TNS_PREFIX; static MetadataReader s_metadataReader; @@ -260,6 +281,7 @@ class MetadataNode { v8::Persistent* implementationObject; std::string fullClassName; + uint64_t defaultOverrides = 0; }; struct TypeMetadata { @@ -335,6 +357,9 @@ class MetadataNode { robin_hood::unordered_node_map Instances; + // This runtime's strings for each interface's DefaultMethodNames, in bit order. + robin_hood::unordered_map>> DefaultMethodNameKeys; + /* * Owns every callback payload this runtime hands to V8 as External * or FunctionTemplate data -- MethodCallbackData, FieldCallbackData, 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 285c21928..f406c29c2 100644 --- a/test-app/runtime/src/main/java/com/tns/DexFactory.java +++ b/test-app/runtime/src/main/java/com/tns/DexFactory.java @@ -4,6 +4,8 @@ import android.util.Log; import com.tns.bindings.AnnotationDescriptor; +import com.tns.bindings.DefaultMethods; +import com.tns.bindings.Dump; import com.tns.bindings.ProxyGenerator; import com.tns.bindings.desc.ClassDescriptor; import com.tns.bindings.desc.reflection.ClassInfo; @@ -23,9 +25,12 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; @@ -46,6 +51,10 @@ public class DexFactory { private ProxyGenerator proxyGenerator; private HashMap> injectedDexClasses = new HashMap>(); + // Process-wide: injection puts a generated class in the app's class loader, where every + // runtime's lookup of a prebuilt class by that name then finds it. + private static final Set generatedClassNames = Collections.newSetFromMap(new ConcurrentHashMap()); + DexFactory(Logger logger, ClassLoader classLoader, File dexBaseDir, String dexThumb, ClassStorageService classStorageService) { this(logger, classLoader, dexBaseDir, dexThumb, classStorageService, false); } @@ -79,6 +88,14 @@ public class DexFactory { static long totalLoadDexTime = 0; public Class resolveClass(String baseClassName, String name, String className, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface) throws ClassNotFoundException, IOException { + // The interface's class name plus this suffix asks for the class that also stubs its + // default methods. A prebuilt class of the interface is used instead when there is one. + boolean overridesDefaults = isInterface && className.startsWith(COM_TNS_GEN_PREFIX) && className.endsWith(Dump.DEFAULT_OVERRIDING_SUFFIX); + if (overridesDefaults) { + className = className.substring(0, className.length() - Dump.DEFAULT_OVERRIDING_SUFFIX.length()); + baseClassName = ""; + } + String fullClassName = className.replace("$", "_"); String originalFullClassName = fullClassName; @@ -91,10 +108,19 @@ public Class resolveClass(String baseClassName, String name, String className if (pregeneratedClass == null) { pregeneratedClass = loadPregeneratedClass(fullClassName.replace("-", "_")); } + // Once injected, the class generated for the interface loads by the same name. + if (overridesDefaults && pregeneratedClass != null && generatedClassNames.contains(pregeneratedClass.getName())) { + pregeneratedClass = null; + } if (pregeneratedClass != null) { return pregeneratedClass; } + if (overridesDefaults) { + fullClassName += Dump.DEFAULT_OVERRIDING_SUFFIX; + originalFullClassName = fullClassName; + } + // new: com.tns.gen.android.widget.DatePicker_MyActivity_59_56_ // old: com.tns.tests.Button1_fMyActivity_l56_c44__MyButton // ne1: com.tns.tests.Button1_MyActivity_58_44_MyButton_0 @@ -141,9 +167,9 @@ public Class resolveClass(String baseClassName, String name, String className String dexFilePath; if (isInterface && !isNamedProxy) { - dexFilePath = this.generateDex(name, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface); + dexFilePath = this.generateDex(name, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, overridesDefaults); } else { - dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface); + dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, false); } dexFile = new File(dexFilePath); long stopGenTime = System.nanoTime(); @@ -197,6 +223,7 @@ public Class resolveClass(String baseClassName, String name, String className result = dexClassLoader.loadClass(classNameToLoad); } + generatedClassNames.add(result.getName()); classStorageService.storeClass(result.getName(), result); this.injectedDexClasses.put(originalFullClassName, result); @@ -344,7 +371,7 @@ private File getDexFile(String className, String contentDigest) throws InvalidCl return null; } - private String generateDex(String proxyName, String contentDigest, String className, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface) throws ClassNotFoundException, IOException { + private String generateDex(String proxyName, String contentDigest, String className, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface, boolean overridesDefaults) throws ClassNotFoundException, IOException { Class classToProxy = Class.forName(className); HashSet methodOverridesSet = null; @@ -368,7 +395,8 @@ private String generateDex(String proxyName, String contentDigest, String classN } AnnotationDescriptor[] annotations = null; - return proxyGenerator.generateProxy(proxyName, contentDigest, new ClassInfo(classToProxy), methodOverridesSet, implementedInterfacesSet, isInterface, annotations); + List defaultMethods = overridesDefaults ? DefaultMethods.collect(classToProxy) : null; + return proxyGenerator.generateProxy(proxyName, contentDigest, new ClassInfo(classToProxy), methodOverridesSet, implementedInterfacesSet, isInterface, annotations, defaultMethods); } private void updateDexThumbAndPurgeCache() { diff --git a/test-app/runtime/src/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java index dd7d12d2e..93a9028cb 100644 --- a/test-app/runtime/src/main/java/com/tns/Runtime.java +++ b/test-app/runtime/src/main/java/com/tns/Runtime.java @@ -3,6 +3,7 @@ import android.os.Handler; import android.os.Looper; +import com.tns.bindings.DefaultMethods; import com.tns.bindings.ProxyGenerator; import com.tns.system.classes.caching.impl.ClassCacheImpl; import com.tns.system.classes.loading.ClassStorageService; @@ -976,6 +977,55 @@ private int createJSInstance(Object instance) { return javaObjectID; } + /* + * DefaultMethods.names of an interface, in which bit i of an instance's default-overrides + * mask names the i-th. Native asks once per interface per process. Never throws: an + * interface it cannot inspect is treated as having no default methods. + */ + @RuntimeCallable + private static String[] getDefaultMethodNames(String interfaceName) { + if (android.os.Build.VERSION.SDK_INT < 24) { + return new String[0]; + } + try { + Class iface = classStorageService.retrieveClass(interfaceName.replace('/', '.')); + String[] names = DefaultMethods.names(iface); + if (names.length > DefaultMethods.MAX_DISPATCHED_NAMES) { + android.util.Log.w("JS", iface.getName() + " has " + names.length + " default method names; JS implementations of those after " + + names[DefaultMethods.MAX_DISPATCHED_NAMES - 1] + " are not called from Java, which runs their Java bodies."); + } + return names; + } catch (Throwable e) { + android.util.Log.w("JS", "Could not list the default methods of " + interfaceName + ": " + e); + return new String[0]; + } + } + + private static final ConcurrentHashMap interfaceDefaultMethods = new ConcurrentHashMap(); + + /* + * Called by a generated class's stub of a default method the instance's JS object does + * not implement: runs the interface's body on the calling thread. key is + * DefaultMethods.key of the method, which declaringInterface declares. + */ + public static Object callInterfaceDefault(Object receiver, Class declaringInterface, String key, Object[] args) { + Method method = interfaceDefaultMethods.get(key); + if (method == null || method.getDeclaringClass() != declaringInterface) { + method = findInterfaceDefault(declaringInterface, key); + interfaceDefaultMethods.put(key, method); + } + return invokeInterfaceDefault(receiver, method, args); + } + + private static Method findInterfaceDefault(Class declaringInterface, String key) { + for (Method method : declaringInterface.getDeclaredMethods()) { + if (DefaultMethods.key(method).equals(key)) { + return method; + } + } + throw new NoSuchMethodError(key); + } + @RuntimeCallable private static String[] getTypeMetadata(String className, int index) throws ClassNotFoundException { Class clazz = classStorageService.retrieveClass(className); 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 new file mode 100644 index 000000000..cf8e6a98c --- /dev/null +++ b/test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java @@ -0,0 +1,189 @@ +package com.tns.bindings; + +import com.tns.bindings.desc.ClassDescriptor; +import com.tns.bindings.desc.reflection.ClassInfo; + +import org.junit.Test; +import org.ow2.asmdex.ApplicationReader; +import org.ow2.asmdex.ApplicationVisitor; +import org.ow2.asmdex.ClassVisitor; +import org.ow2.asmdex.FieldVisitor; +import org.ow2.asmdex.MethodVisitor; +import org.ow2.asmdex.Opcodes; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.PrimitiveIterator; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class DefaultMethodsTest { + + interface Base { + default String inherited() { + return "base"; + } + + default String reabstracted() { + return "base"; + } + + default String redefined() { + return "base"; + } + } + + interface Derived extends Base { + String reabstracted(); + + @Override + default String redefined() { + return "derived"; + } + + default String overloaded(int value) { + return "int"; + } + + default String overloaded(String value) { + return "string"; + } + } + + interface Other { + default String inherited() { + return "other"; + } + } + + interface Conflicting extends Base, Other { + @Override + default String inherited() { + return "conflicting"; + } + } + + interface WithoutResolution extends Derived { + static String helper() { + return "static"; + } + } + + interface Covariant extends Iterator { + @Override + default Integer next() { + return 1; + } + } + + @Test + public void namesAreTheSortedDistinctNamesOfTheMostSpecificDefaults() { + assertArrayEquals(new String[]{"inherited", "overloaded", "redefined"}, DefaultMethods.names(Derived.class)); + assertArrayEquals(new String[]{"inherited", "overloaded", "redefined"}, DefaultMethods.names(WithoutResolution.class)); + assertArrayEquals(new String[]{"forEachRemaining", "remove"}, DefaultMethods.names(Iterator.class)); + assertArrayEquals(new String[]{"forEachRemaining", "next", "remove"}, DefaultMethods.names(PrimitiveIterator.OfInt.class)); + assertArrayEquals(new String[0], DefaultMethods.names(Runnable.class)); + } + + @Test + public void collectsTheOverridingDeclarationAndNoBridges() throws Exception { + List derived = DefaultMethods.collect(Derived.class); + assertTrue(derived.contains(Derived.class.getMethod("redefined"))); + assertFalse(derived.contains(Base.class.getMethod("redefined"))); + assertTrue(derived.contains(Derived.class.getMethod("overloaded", int.class))); + assertTrue(derived.contains(Derived.class.getMethod("overloaded", String.class))); + assertEquals(4, derived.size()); + + assertTrue(DefaultMethods.collect(Conflicting.class).contains(Conflicting.class.getMethod("inherited"))); + + List covariant = DefaultMethods.collect(Covariant.class); + for (Method method : covariant) { + assertFalse(method.toString(), method.isBridge()); + } + assertTrue(covariant.contains(Covariant.class.getMethod("next"))); + assertEquals(Integer.class, Covariant.class.getMethod("next").getReturnType()); + } + + @Test + public void keyNamesTheDeclaringInterfaceAndTheSignature() throws Exception { + assertEquals("java.util.Iterator.remove()void", DefaultMethods.key(Iterator.class.getMethod("remove"))); + assertEquals("com.tns.bindings.DefaultMethodsTest$Derived.overloaded(int)java.lang.String", + DefaultMethods.key(Derived.class.getMethod("overloaded", int.class))); + } + + private static byte[] generate(Class iface, boolean overrideDefaults) { + org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter(); + aw.visit(); + ClassDescriptor descriptor = new ClassInfo(iface); + new Dump().generateProxy(aw, "", descriptor, null, new HashSet(), null, + overrideDefaults ? DefaultMethods.collect(iface) : null); + aw.visitEnd(); + return aw.toByteArray(); + } + + private static final class Shape { + String className; + final List fields = new ArrayList<>(); + final List methods = new ArrayList<>(); + } + + private static Shape read(byte[] dex) { + final Shape shape = new Shape(); + new ApplicationReader(Opcodes.ASM4, dex).accept(new ApplicationVisitor(Opcodes.ASM4) { + @Override + public ClassVisitor visitClass(int access, String name, String[] signature, String superName, String[] interfaces) { + shape.className = name; + return new ClassVisitor(Opcodes.ASM4) { + @Override + public FieldVisitor visitField(int access, String name, String desc, String[] signature, Object value) { + shape.fields.add(name + ":" + desc); + return null; + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String[] signature, String[] exceptions) { + shape.methods.add(name + desc); + return null; + } + }; + } + }, ApplicationReader.SKIP_CODE); + return shape; + } + + @Test + public void theDefaultOverridingClassAddsAStubPerDefaultAndTheMask() { + Shape plain = read(generate(PrimitiveIterator.OfInt.class, false)); + Shape overriding = read(generate(PrimitiveIterator.OfInt.class, true)); + + assertEquals("Lcom/tns/gen/java/util/PrimitiveIterator_OfInt;", plain.className); + assertEquals("Lcom/tns/gen/java/util/PrimitiveIterator_OfInt" + Dump.DEFAULT_OVERRIDING_SUFFIX + ";", overriding.className); + + assertFalse(plain.fields.contains("defaultOverrides__ns:J")); + assertTrue(overriding.fields.contains("defaultOverrides__ns:J")); + + List added = new ArrayList<>(overriding.methods); + added.removeAll(plain.methods); + added.sort(null); + // dex descriptors: return type first + assertEquals(Arrays.asList( + "forEachRemainingVLjava/util/function/Consumer;", + "forEachRemainingVLjava/util/function/IntConsumer;", + "nextLjava/lang/Integer;", + "removeV"), added); + assertTrue(overriding.methods.containsAll(plain.methods)); + } + + @Test + public void generationIsByteStable() { + assertArrayEquals(generate(Iterator.class, true), generate(Iterator.class, true)); + assertArrayEquals(generate(Iterator.class, false), generate(Iterator.class, false)); + } +} From 9dcc8a5c3b6b658d7ca65035534690c780f64033 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 03:13:05 -0300 Subject: [PATCH 03/16] fix(bindings): call JS implementations of inherited default methods in class extends A class extended at runtime gets a stub for each method of its class hierarchy the JS object names, and for each abstract method, but not for the default methods it inherits: neither those of an interface it lists (interfaces: [I], @Interfaces) nor those its base class inherits without overriding. Java then runs their bodies and never calls the JS implementation. On API 24+, stub the inherited default methods the JS object names too: the most specific default for each signature that no class in the hierarchy declares. The class is already generated per call site, so like its other overrides they always call JS. Desugared app defaults (minSdk below 24) are unchanged: D8 gives the base class a synthetic forwarding method, which generated classes do not override. --- .../testInterfaceDefaultMethodOverrides.js | 74 +++++++++++++++++++ .../com/tns/tests/DefaultMethodFixtures.java | 20 +++++ .../java/com/tns/bindings/DefaultMethods.java | 18 +++++ .../src/main/java/com/tns/bindings/Dump.java | 28 ++++++- .../src/main/java/com/tns/DexFactory.java | 17 ++++- .../com/tns/bindings/DefaultMethodsTest.java | 27 +++++++ 6 files changed, 178 insertions(+), 6 deletions(-) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index 946f320ab..6b0863e84 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -264,6 +264,80 @@ describe("Interface default methods implemented in JS", function () { expect(aliasedRemoves).toBe(1); }); + it("are called through a class extend that implements the interface", function () { + if (sdk < 24) { + return; + } + var O = java.lang.Object; + var removes = 0; + var WithRemove = O.extend({ + interfaces: [It], + hasNext: function () { return false; }, + next: function () { return null; }, + remove: function () { removes++; } + }); + var withRemove = new WithRemove(); + expect(F.isRuntimeGenerated(withRemove)).toBe(true); + expect(F.remove(withRemove)).toBe("removed"); + expect(removes).toBe(1); + + var WithoutRemove = O.extend({ + interfaces: [It], + hasNext: function () { return false; }, + next: function () { return null; } + }); + expect(F.remove(new WithoutRemove())).toBe("java.lang.UnsupportedOperationException"); + }); + + it("are called through a class extend whose base class inherits them", function () { + var hasAsIterator = false; + try { + java.util.Enumeration.class.getMethod("asIterator", []); + hasAsIterator = true; + } catch (e) { + } + if (!hasAsIterator) { + return; + } + var Tokenizer = java.util.StringTokenizer; + var asIteratorCalls = 0; + var Tokens = Tokenizer.extend({ + asIterator: function () { + asIteratorCalls++; + return new java.util.ArrayList().iterator(); + } + }); + var tokens = new Tokens("a b"); + expect(F.isRuntimeGenerated(tokens)).toBe(true); + expect(F.asIterator(tokens)).toBe("java.util.ArrayList$Itr"); + expect(asIteratorCalls).toBe(1); + }); + + it("are called through a class extend of an app class, unless D8 desugared them", function () { + if (sdk < 24) { + return; + } + var CarProducer = com.tns.tests.interfaces.defaultmethods.impl.CarProducerImpl; + var produced = 0; + var Producing = CarProducer.extend({ + produce: function () { + produced++; + return "js produce"; + } + }); + var producing = new Producing(); + + if (F.isDesugared()) { + // D8 gives CarProducerImpl a synthetic produce() forwarding to the moved + // body; generated classes do not override synthetic methods. + expect(F.produce(producing)).toBe("default produce in CarProducer"); + expect(produced).toBe(0); + return; + } + expect(F.produce(producing)).toBe("js produce"); + expect(produced).toBe(1); + }); + it("reach JS for an interface whose methods are all default methods, unless D8 desugared them", function () { if (sdk < 24) { return; diff --git a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java index 400e99793..16cb5d514 100644 --- a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -1,8 +1,10 @@ package com.tns.tests; import com.tns.tests.interfaces.defaultmethods.contract.AllDefaultListener; +import com.tns.tests.interfaces.defaultmethods.contract.Producer; import java.util.ArrayList; +import java.util.Enumeration; import java.util.Iterator; import java.util.List; import java.util.PrimitiveIterator; @@ -118,6 +120,24 @@ public static String fire(AllDefaultListener listener) { } } + public static String produce(Producer producer) { + try { + return producer.produce(); + } catch (Throwable t) { + return t.getClass().getName(); + } + } + + // Only on API levels whose Enumeration has the asIterator() default method. + @SuppressWarnings("NewApi") + public static String asIterator(Enumeration enumeration) { + try { + return enumeration.asIterator().getClass().getName(); + } catch (Throwable t) { + return t.getClass().getName(); + } + } + public static boolean isDesugared() throws NoSuchMethodException { return !AllDefaultListener.class.getMethod("describe").isDefault(); } 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 948336424..8e8012813 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 @@ -37,6 +37,24 @@ public static List collect(Class iface) { return collect(Collections.>singletonList(iface), Collections.emptySet()); } + /** + * The default methods a subclass of the class that also implements the given interfaces + * 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<>(); + 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)); + } + } + } + return collect(roots, classSignatures); + } + private static String signature(Method method) { return method.getName() + Arrays.toString(method.getParameterTypes()); } 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 8cdfc980a..1150845d1 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,10 +181,12 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto /** * defaultMethods, for an anonymous interface implementation, are the interface's * DefaultMethods.collect: the class gets the DEFAULT_OVERRIDING_SUFFIX name and a stub - * for each of them as well. null generates the class without them. + * for each of them as well. For a 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) { String classSignature = getAsmDescriptor(classTo); + boolean overridesDefaults = defaultMethods != null && classTo.isInterface(); String tnsClassSignature; if (proxyName.contains(".")) { @@ -195,7 +197,7 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto if (!classTo.isInterface()) { tnsClassSignature += CLASS_NAME_LOCATION_SEPARATOR + proxyName; - } else if (defaultMethods != null) { + } else if (overridesDefaults) { tnsClassSignature += DEFAULT_OVERRIDING_SUFFIX; } @@ -206,9 +208,12 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto MethodDescriptor[] methods = getSupportedMethods(classTo, methodOverrides, implementedInterfaces); methods = groupMethodsByNameAndSignature(methods); + if (defaultMethods != null && !overridesDefaults) { + methods = withInheritedDefaults(methods, defaultMethods); + } generateFields(cv); - if (defaultMethods != null) { + if (overridesDefaults) { FieldVisitor fv = cv.visitField(org.ow2.asmdex.Opcodes.ACC_PRIVATE | org.ow2.asmdex.Opcodes.ACC_VOLATILE, DEFAULT_OVERRIDES_FIELD_NAME, "J", null, null); fv.visitEnd(); } @@ -220,13 +225,28 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto generateMethods(cv, classTo, methods, classSignature, tnsClassSignature); - if (defaultMethods != null) { + if (overridesDefaults) { generateDefaultMethodStubs(cv, defaultMethods, methods, classSignature, tnsClassSignature); } cv.visitEnd(); } + private MethodDescriptor[] withInheritedDefaults(MethodDescriptor[] methods, List defaultMethods) { + List result = new ArrayList(Arrays.asList(methods)); + Set signatures = new HashSet(); + for (MethodDescriptor method : methods) { + signatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method)); + } + for (java.lang.reflect.Method defaultMethod : defaultMethods) { + MethodDescriptor method = new MethodInfo(defaultMethod); + if (signatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method))) { + result.add(method); + } + } + return result.toArray(new MethodDescriptor[result.size()]); + } + private void generateDefaultMethodStubs(ClassVisitor cv, List defaultMethods, MethodDescriptor[] generatedMethods, String classSignature, String tnsClassSignature) { Set generatedSignatures = new HashSet(); for (MethodDescriptor generated : generatedMethods) { 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 f406c29c2..c9a995867 100644 --- a/test-app/runtime/src/main/java/com/tns/DexFactory.java +++ b/test-app/runtime/src/main/java/com/tns/DexFactory.java @@ -376,6 +376,7 @@ private String generateDex(String proxyName, String contentDigest, String classN HashSet methodOverridesSet = null; HashSet implementedInterfacesSet = new HashSet(); + List> implementedInterfaceClasses = new ArrayList>(); if (methodOverrides != null) { methodOverridesSet = new HashSet(); @@ -389,13 +390,25 @@ private String generateDex(String proxyName, String contentDigest, String classN if (implementedInterfaces.length > 0) { for (int j = 0; j < implementedInterfaces.length; j++) { if (!implementedInterfaces[j].isEmpty()) { - implementedInterfacesSet.add(new ClassInfo(Class.forName(implementedInterfaces[j]))); + Class implementedInterface = Class.forName(implementedInterfaces[j]); + implementedInterfacesSet.add(new ClassInfo(implementedInterface)); + implementedInterfaceClasses.add(implementedInterface); } } } AnnotationDescriptor[] annotations = null; - List defaultMethods = overridesDefaults ? DefaultMethods.collect(classToProxy) : null; + List defaultMethods = null; + if (overridesDefaults) { + defaultMethods = DefaultMethods.collect(classToProxy); + } else if (!classToProxy.isInterface() && Build.VERSION.SDK_INT >= 24) { + defaultMethods = new ArrayList(); + for (Method inherited : DefaultMethods.collect(classToProxy, implementedInterfaceClasses)) { + if (methodOverridesSet == null || methodOverridesSet.contains(inherited.getName())) { + defaultMethods.add(inherited); + } + } + } return proxyGenerator.generateProxy(proxyName, contentDigest, new ClassInfo(classToProxy), methodOverridesSet, implementedInterfacesSet, isInterface, annotations, defaultMethods); } 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 cf8e6a98c..0a5aec087 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 @@ -111,6 +111,33 @@ public void collectsTheOverridingDeclarationAndNoBridges() throws Exception { assertEquals(Integer.class, Covariant.class.getMethod("next").getReturnType()); } + static class Implementor implements Derived { + @Override + public String reabstracted() { + return "class"; + } + + @Override + public String redefined() { + return "class"; + } + } + + @Test + public void aClassInheritsTheDefaultsNoClassInItsHierarchyDeclares() throws Exception { + assertEquals(Arrays.asList( + Base.class.getMethod("inherited"), + Derived.class.getMethod("overloaded", int.class), + Derived.class.getMethod("overloaded", String.class)), + DefaultMethods.collect(Implementor.class, new ArrayList>())); + + // Base.inherited() and Other.inherited() conflict: neither is inherited. + assertEquals(Arrays.asList( + Derived.class.getMethod("overloaded", int.class), + Derived.class.getMethod("overloaded", String.class)), + DefaultMethods.collect(Implementor.class, Arrays.>asList(Other.class))); + } + @Test public void keyNamesTheDeclaringInterfaceAndTheSignature() throws Exception { assertEquals("java.util.Iterator.remove()void", DefaultMethods.key(Iterator.class.getMethod("remove"))); From 63e67e85053d4683fcf4f28243c453735ed85394 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 10:07:15 -0300 Subject: [PATCH 04/16] fix(bindings): call JS implementations of default methods in named interface extends A class generated at runtime for Interface.extend("a.b.C", {...}) or a @JavaProxy("a.b.C") class extending an interface stubbed only the interface's abstract methods, so Java ran the body of every default method, also those the implementation object implements. This is the shape such code takes when the static binding generator did not prebuild the class, e.g. code a dev server serves. A named class belongs to one extend() call, and its dex cache key already includes the implementation object's method names, so it needs neither the "-defaults" class nor the mask: on API 24+ it now stubs the interface's default methods the implementation object names, each always calling JS like a class's overrides, and leaves the others to their Java bodies. A prebuilt named class already overrides the defaults it lists; the specs pair both. Only a request without a base class name, which only native sends, asks for the "-defaults" class, so a name the script chose that ends in "-defaults" can no longer be taken for one. --- test-app/.gitignore | 2 + .../testInterfaceDefaultMethodOverrides.js | 109 ++++++++++++++++++ .../com/tns/tests/DefaultMethodFixtures.java | 8 ++ .../src/main/java/com/tns/bindings/Dump.java | 11 +- .../src/main/java/com/tns/DexFactory.java | 14 ++- .../com/tns/bindings/DefaultMethodsTest.java | 16 +++ 6 files changed, 151 insertions(+), 9 deletions(-) diff --git a/test-app/.gitignore b/test-app/.gitignore index e94ad2aa9..d9360d209 100644 --- a/test-app/.gitignore +++ b/test-app/.gitignore @@ -23,4 +23,6 @@ treeStringsStream.dat treeValueStream.dat NativeScriptActivity.java NativeScriptApplication.java +# named extend() classes the static binding generator writes for the specs +app/src/main/java/com/tns/tests/defaults/ **/com/tns/gen \ No newline at end of file diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index 6b0863e84..7e14750fc 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -338,6 +338,115 @@ describe("Interface default methods implemented in JS", function () { expect(produced).toBe(1); }); + function namedIterator(drains) { + return { + hasNext: function () { return false; }, + next: function () { return null; }, + forEachRemaining: function () { drains.push("forEachRemaining"); } + }; + } + + // Computed member: the static binding generator does not see these named extends. + var ext = "ex" + "tend"; + + it("are called through a named class extended from the interface at runtime", function () { + if (sdk < 24) { + return; + } + var drains = []; + var Named = It[ext]("com.tns.tests.defaults.NamedRuntimeIterator", namedIterator(drains)); + var named = new Named(); + + expect(F.className(named)).toBe("com.tns.tests.defaults.NamedRuntimeIterator"); + expect(F.isRuntimeGenerated(named)).toBe(true); + expect(F.drain(named)).toBe(""); + expect(drains).toEqual(["forEachRemaining"]); + expect(F.remove(named)).toBe("java.lang.UnsupportedOperationException"); + }); + + it("are called through a named class the static binding generator prebuilt from the interface", function () { + if (sdk < 24) { + return; + } + var drains = []; + // An object literal: the static binding generator reads the methods it lists. + var Named = java.util.Iterator.extend("com.tns.tests.defaults.NamedPrebuiltIterator", { + hasNext: function () { return false; }, + next: function () { return null; }, + forEachRemaining: function () { drains.push("forEachRemaining"); } + }); + var named = new Named(); + + expect(F.className(named)).toBe("com.tns.tests.defaults.NamedPrebuiltIterator"); + expect(F.isRuntimeGenerated(named)).toBe(false); + expect(F.drain(named)).toBe(""); + expect(drains).toEqual(["forEachRemaining"]); + expect(F.remove(named)).toBe("java.lang.UnsupportedOperationException"); + }); + + it("are called through a JavaProxy-named class extended from the interface at runtime", function () { + if (sdk < 24) { + return; + } + var Sized = (function (_super) { + __extends(Sized, _super); + function Sized() { + return _super !== null && _super.apply(this, arguments) || this; + } + Sized.prototype.tryAdvance = function () { return false; }; + Sized.prototype.trySplit = function () { return null; }; + Sized.prototype.estimateSize = function () { return 9; }; + Sized.prototype.characteristics = function () { return Split.SIZED; }; + // The Java body would answer estimateSize(), 9. + Sized.prototype.getExactSizeIfKnown = function () { return 11; }; + return Sized; + }(Split)); + var Decorated = JavaProxy("com.tns.tests.defaults.DecoratedRuntimeSpliterator")(Sized); + var decorated = new Decorated(); + + expect(F.className(decorated)).toBe("com.tns.tests.defaults.DecoratedRuntimeSpliterator"); + expect(F.isRuntimeGenerated(decorated)).toBe(true); + expect(F.spliteratorDefaults(decorated)).toBe("11|true|false"); + expect(F.getComparator(decorated)).toBe("java.lang.IllegalStateException"); + }); + + it("are called through a named class extended at runtime from a class implementing the interface", function () { + if (sdk < 24) { + return; + } + var drains = []; + var implementation = namedIterator(drains); + implementation.interfaces = [It]; + var Named = java.lang.Object[ext]("com.tns.tests.defaults.NamedRuntimeObjectIterator", implementation); + var named = new Named(); + + expect(F.className(named)).toBe("com.tns.tests.defaults.NamedRuntimeObjectIterator"); + expect(F.isRuntimeGenerated(named)).toBe(true); + expect(F.drain(named)).toBe(""); + expect(drains).toEqual(["forEachRemaining"]); + expect(F.remove(named)).toBe("java.lang.UnsupportedOperationException"); + }); + + it("are called through a named class the static binding generator prebuilt from a class implementing the interface", function () { + if (sdk < 24) { + return; + } + var drains = []; + var Named = java.lang.Object.extend("com.tns.tests.defaults.NamedPrebuiltObjectIterator", { + interfaces: [java.util.Iterator], + hasNext: function () { return false; }, + next: function () { return null; }, + forEachRemaining: function () { drains.push("forEachRemaining"); } + }); + var named = new Named(); + + expect(F.className(named)).toBe("com.tns.tests.defaults.NamedPrebuiltObjectIterator"); + expect(F.isRuntimeGenerated(named)).toBe(false); + expect(F.drain(named)).toBe(""); + expect(drains).toEqual(["forEachRemaining"]); + expect(F.remove(named)).toBe("java.lang.UnsupportedOperationException"); + }); + it("reach JS for an interface whose methods are all default methods, unless D8 desugared them", function () { if (sdk < 24) { return; diff --git a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java index 16cb5d514..a3d7a8124 100644 --- a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -105,6 +105,14 @@ public static String longNegate(LongPredicate p, long value) { return p.test(value) + "|" + p.negate().test(value); } + public static String getComparator(Spliterator spliterator) { + try { + return java.util.Objects.toString(spliterator.getComparator()); + } catch (Throwable t) { + return t.getClass().getName(); + } + } + public static String spliteratorDefaults(Spliterator spliterator) { return spliterator.getExactSizeIfKnown() + "|" + spliterator.hasCharacteristics(Spliterator.SIZED) + "|" + spliterator.hasCharacteristics(Spliterator.SORTED); 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 1150845d1..2810bdca1 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 @@ -179,14 +179,15 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto } /** - * defaultMethods, for an anonymous interface implementation, 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, they are inherited default methods the JS - * object implements, stubbed like the class's other overrides. null adds neither. + * 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. */ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescriptor classTo, HashSet methodOverrides, HashSet implementedInterfaces, AnnotationDescriptor[] annotations, List defaultMethods) { String classSignature = getAsmDescriptor(classTo); - boolean overridesDefaults = defaultMethods != null && classTo.isInterface(); + boolean overridesDefaults = defaultMethods != null && classTo.isInterface() && !proxyName.contains("."); String tnsClassSignature; if (proxyName.contains(".")) { 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 c9a995867..d628701b7 100644 --- a/test-app/runtime/src/main/java/com/tns/DexFactory.java +++ b/test-app/runtime/src/main/java/com/tns/DexFactory.java @@ -90,10 +90,11 @@ public class DexFactory { public Class resolveClass(String baseClassName, String name, String className, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface) throws ClassNotFoundException, IOException { // The interface's class name plus this suffix asks for the class that also stubs its // default methods. A prebuilt class of the interface is used instead when there is one. - boolean overridesDefaults = isInterface && className.startsWith(COM_TNS_GEN_PREFIX) && className.endsWith(Dump.DEFAULT_OVERRIDING_SUFFIX); + // Only native asks for it, without a base class name; an extend() name the script + // chose always comes with the base class's. + boolean overridesDefaults = isInterface && baseClassName.isEmpty() && className.startsWith(COM_TNS_GEN_PREFIX) && className.endsWith(Dump.DEFAULT_OVERRIDING_SUFFIX); if (overridesDefaults) { className = className.substring(0, className.length() - Dump.DEFAULT_OVERRIDING_SUFFIX.length()); - baseClassName = ""; } String fullClassName = className.replace("$", "_"); @@ -401,9 +402,14 @@ private String generateDex(String proxyName, String contentDigest, String classN List defaultMethods = null; if (overridesDefaults) { defaultMethods = DefaultMethods.collect(classToProxy); - } else if (!classToProxy.isInterface() && Build.VERSION.SDK_INT >= 24) { + } 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); defaultMethods = new ArrayList(); - for (Method inherited : DefaultMethods.collect(classToProxy, implementedInterfaceClasses)) { + for (Method inherited : inheritedDefaults) { if (methodOverridesSet == null || methodOverridesSet.contains(inherited.getName())) { defaultMethods.add(inherited); } 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 0a5aec087..c030fcc5f 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 @@ -208,6 +208,22 @@ public void theDefaultOverridingClassAddsAStubPerDefaultAndTheMask() { assertTrue(overriding.methods.containsAll(plain.methods)); } + @Test + public void aNamedInterfaceImplementationStubsOnlyTheGivenDefaults() throws Exception { + org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter(); + aw.visit(); + List named = new ArrayList<>(); + named.add(Iterator.class.getMethod("forEachRemaining", java.util.function.Consumer.class)); + new Dump().generateProxy(aw, "a.b.NamedIterator", new ClassInfo(Iterator.class), null, new HashSet(), null, named); + aw.visitEnd(); + Shape shape = read(aw.toByteArray()); + + assertEquals("La/b/NamedIterator;", shape.className); + assertFalse(shape.fields.contains("defaultOverrides__ns:J")); + assertTrue(shape.methods.contains("forEachRemainingVLjava/util/function/Consumer;")); + assertFalse(shape.methods.contains("removeV")); + } + @Test public void generationIsByteStable() { assertArrayEquals(generate(Iterator.class, true), generate(Iterator.class, true)); From 3fa214c145010afebddf20ece3e99b82a94e4ce3 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 10:52:24 -0300 Subject: [PATCH 05/16] fix(bindings): resolve the default-overriding class without reading the JS object On a class-cache miss, resolving a class lists the implementation object's method names and interfaces, reading every own enumerable property with Get. For the "-defaults" class that ran the getter of an accessor-defined method during construction, and a getter that throws aborted the process (ToLocalChecked on an empty handle). That class does not depend on the implementation object, so resolve it with none, for new Interface({...}) and for an anonymous Interface.extend({...}). Its dex cache key then depends on the interface alone: one cached dex per interface. --- .../testInterfaceDefaultMethodOverrides.js | 46 +++++++++++++++++++ .../com/tns/tests/DefaultMethodFixtures.java | 5 ++ .../runtime/src/main/cpp/CallbackHandlers.cpp | 4 +- .../runtime/src/main/cpp/MetadataNode.cpp | 2 +- 4 files changed, 55 insertions(+), 2 deletions(-) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index 7e14750fc..70fad98ec 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -447,6 +447,52 @@ describe("Interface default methods implemented in JS", function () { expect(F.remove(named)).toBe("java.lang.UnsupportedOperationException"); }); + it("do not run an accessor's getter while the class is first resolved", function () { + if (sdk < 24) { + return; + } + // No other spec implements this interface, so its class is resolved here. + var DoublePred = java.util.function.DoublePredicate; + var getterCalls = 0; + var implementation = { test: function (value) { return value > 0; } }; + Object.defineProperty(implementation, "negate", { + enumerable: true, + get: function () { + getterCalls++; + return function () { + return new DoublePred({ test: function () { return true; } }); + }; + } + }); + var predicate = new DoublePred(implementation); + + expect(getterCalls).toBe(0); + expect(F.className(predicate)).toBe("com.tns.gen.java.util.function.DoublePredicate" + SUFFIX); + expect(F.doubleNegate(predicate, 1)).toBe("true|true"); + expect(getterCalls).toBe(1); + }); + + it("construct an instance whose accessor's getter throws", function () { + if (sdk < 24) { + return; + } + // No other spec implements this interface, so its class is resolved here. + var LongOperator = java.util.function.LongUnaryOperator; + var getterCalls = 0; + var implementation = { applyAsLong: function (value) { return value; } }; + Object.defineProperty(implementation, "andThen", { + enumerable: true, + get: function () { + getterCalls++; + throw new Error("getter must not run during construction"); + } + }); + var operator = new LongOperator(implementation); + + expect(getterCalls).toBe(0); + expect(F.className(operator)).toBe("com.tns.gen.java.util.function.LongUnaryOperator" + SUFFIX); + }); + it("reach JS for an interface whose methods are all default methods, unless D8 desugared them", function () { if (sdk < 24) { return; diff --git a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java index a3d7a8124..eb93cac66 100644 --- a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -10,6 +10,7 @@ import java.util.PrimitiveIterator; import java.util.Spliterator; import java.util.function.Consumer; +import java.util.function.DoublePredicate; import java.util.function.IntConsumer; import java.util.function.IntPredicate; import java.util.function.LongPredicate; @@ -105,6 +106,10 @@ public static String longNegate(LongPredicate p, long value) { return p.test(value) + "|" + p.negate().test(value); } + public static String doubleNegate(DoublePredicate p, double value) { + return p.test(value) + "|" + p.negate().test(value); + } + public static String getComparator(Spliterator spliterator) { try { return java.util.Objects.toString(spliterator.getComparator()); diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp index 594cf849d..b749dea5a 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp @@ -206,8 +206,10 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &j JEnv env; + // The default-overriding class does not depend on the implementation object, whose + // properties ResolveClass would otherwise read, getters included. jclass generatedJavaClass = ResolveClass(isolate, baseClassName, fullClassName, - implementationObject, + defaultOverrides != 0 ? Local() : implementationObject, isInterface); int javaObjectID = objectManager->GenerateNewObjectID(); diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp index 4b5c58496..454b798bf 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.cpp +++ b/test-app/runtime/src/main/cpp/MetadataNode.cpp @@ -2033,7 +2033,7 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfom_implType + DEFAULT_OVERRIDING_SUFFIX, implementationObject, isInterface) + ? CallbackHandlers::ResolveClass(isolate, string(), node->m_implType + DEFAULT_OVERRIDING_SUFFIX, Local(), isInterface) : CallbackHandlers::ResolveClass(isolate, baseClassName, fullClassName, implementationObject, isInterface); auto fullExtendedName = CallbackHandlers::ResolveClassName(isolate, clazz); DEBUG_WRITE("ExtendsCallMethodHandler: extend full name %s", fullClassName.c_str()); From 1bb49a558f3238a13530daffef97ac91b3b0e6b2 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 10:55:44 -0300 Subject: [PATCH 06/16] fix(bindings): let an extend with an empty interfaces list override defaults The default-overriding class is used for an anonymous Interface.extend only when the implementation object implements no other interface, but the check was whether it has an `interfaces` property at all, so `interfaces: []` silently kept the plain class and Java never called the JS implementations of default methods. Check what resolving the class would list instead: an `interfaces` array with at least one function in it, read in JS without calling Java. --- .../testInterfaceDefaultMethodOverrides.js | 18 ++++++++++++++++++ .../com/tns/tests/DefaultMethodFixtures.java | 6 ++++++ .../runtime/src/main/cpp/CallbackHandlers.cpp | 16 ++++++++++++++++ .../runtime/src/main/cpp/CallbackHandlers.h | 3 +++ test-app/runtime/src/main/cpp/MetadataNode.cpp | 7 ++----- 5 files changed, 45 insertions(+), 5 deletions(-) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index 70fad98ec..9335c27be 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -493,6 +493,24 @@ describe("Interface default methods implemented in JS", function () { expect(F.className(operator)).toBe("com.tns.gen.java.util.function.LongUnaryOperator" + SUFFIX); }); + it("are called through an extend whose implementation object lists no interfaces", function () { + if (sdk < 24) { + return; + } + var BiPred = java.util.function.BiPredicate; + var Same = BiPred[ext]({ + interfaces: [], + test: function (first, second) { return first === second; }, + negate: function () { + return new BiPred({ test: function () { return true; } }); + } + }); + var same = new Same(); + + expect(F.className(same)).toBe("com.tns.gen.java.util.function.BiPredicate" + SUFFIX); + expect(F.biNegate(same, "a", "a")).toBe("true|true"); + }); + it("reach JS for an interface whose methods are all default methods, unless D8 desugared them", function () { if (sdk < 24) { return; diff --git a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java index eb93cac66..dd0b12536 100644 --- a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -9,6 +9,7 @@ import java.util.List; import java.util.PrimitiveIterator; import java.util.Spliterator; +import java.util.function.BiPredicate; import java.util.function.Consumer; import java.util.function.DoublePredicate; import java.util.function.IntConsumer; @@ -110,6 +111,11 @@ public static String doubleNegate(DoublePredicate p, double value) { return p.test(value) + "|" + p.negate().test(value); } + public static String biNegate(BiPredicate p, Object first, Object second) { + BiPredicate predicate = (BiPredicate) p; + return predicate.test(first, second) + "|" + predicate.negate().test(first, second); + } + public static String getComparator(Spliterator spliterator) { try { return java.util.Objects.toString(spliterator.getComparator()); diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp index b749dea5a..f76782bbe 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp @@ -167,6 +167,22 @@ void SetDefaultOverrides(JNIEnv* env, jobject instance, jclass clazz, uint64_t d } } // namespace +bool CallbackHandlers::HasImplementedInterfaces(Isolate *isolate, const Local &implementationObject) { + auto context = GetCreationContextOrCurrent(isolate, implementationObject); + Local prop; + if (!implementationObject->Get(context, String::NewFromUtf8Literal(isolate, "interfaces")).ToLocal(&prop) || !prop->IsArray()) { + return false; + } + auto interfaces = prop.As(); + for (uint32_t i = 0, length = interfaces->Length(); i < length; i++) { + Local element; + if (interfaces->Get(context, i).ToLocal(&element) && element->IsFunction()) { + return true; + } + } + return false; +} + std::vector CallbackHandlers::GetDefaultMethodNames(const std::string &interfaceName) { JEnv env; diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.h b/test-app/runtime/src/main/cpp/CallbackHandlers.h index 4d0eb56e9..b1964b0be 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.h +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.h @@ -43,6 +43,9 @@ namespace tns { const std::string &baseClassName = std::string(), uint64_t defaultOverrides = 0); + // Whether GetImplementedInterfaces would list any interface, without calling Java. + static bool HasImplementedInterfaces(v8::Isolate *isolate, const v8::Local &implementationObject); + // com.tns.Runtime.getDefaultMethodNames of the interface. static std::vector GetDefaultMethodNames(const std::string &interfaceName); diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp index 454b798bf..a9a6912f5 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.cpp +++ b/test-app/runtime/src/main/cpp/MetadataNode.cpp @@ -2026,11 +2026,8 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfoHas(isolate->GetCurrentContext(), interfacesKey).FromMaybe(true)) { - defaultOverrides = node->GetDefaultOverrides(isolate, implementationObject); - } + if (isInterface && !hasDot && !CallbackHandlers::HasImplementedInterfaces(isolate, implementationObject)) { + defaultOverrides = node->GetDefaultOverrides(isolate, implementationObject); } auto clazz = defaultOverrides != 0 ? CallbackHandlers::ResolveClass(isolate, string(), node->m_implType + DEFAULT_OVERRIDING_SUFFIX, Local(), isInterface) From c9cef0c30d4fb61744c7a1e33914d5ec5489bbc2 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 10:56:03 -0300 Subject: [PATCH 07/16] fix(bindings): run inherited defaults of a non-public super-interface The default-overriding class's stub for a default the JS object does not implement named the interface declaring the method in a const-class. For a default declared in a package-private super-interface, a class generated in another package cannot access it, and the call failed with IllegalAccessError where the Java body ran before. Name the interface the class implements, which it can always access, and find the method through that interface's hierarchy by its key (declaring interface, name, parameter and return types), so a covariant redeclaration in a sub-interface is not taken for it. The non-virtual call still targets the declaring interface's method, which JNI does not check access for. --- .../testInterfaceDefaultMethodOverrides.js | 39 +++++++++++++++++++ .../hiddendefaults/HiddenDefaults.java | 12 ++++++ .../hiddendefaults/VisibleDefaults.java | 14 +++++++ .../hiddendefaults/VisibleDefaultsCaller.java | 35 +++++++++++++++++ .../java/com/tns/bindings/DefaultMethods.java | 20 ++++++++++ .../src/main/java/com/tns/bindings/Dump.java | 4 +- .../src/main/java/com/tns/Runtime.java | 21 ++++------ .../com/tns/bindings/DefaultMethodsTest.java | 39 +++++++++++++++++++ 8 files changed, 170 insertions(+), 14 deletions(-) create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/HiddenDefaults.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaults.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaultsCaller.java diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index 9335c27be..d47d5927b 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -511,6 +511,45 @@ describe("Interface default methods implemented in JS", function () { expect(F.biNegate(same, "a", "a")).toBe("true|true"); }); + it("run a default declared in a super-interface the generated class cannot access", function () { + if (sdk < 24) { + return; + } + var H = com.tns.tests.interfaces.hiddendefaults; + var Caller = H.VisibleDefaultsCaller; + var Visible = H.VisibleDefaults; + var calls = []; + var visibleOnly = new Visible({ + name: function () { return "js"; }, + visible: function () { + calls.push("visible"); + return "visible js"; + } + }); + var hiddenOnly = new Visible({ + name: function () { return "js"; }, + hidden: function () { + calls.push("hidden"); + return "hidden js"; + } + }); + + if (Caller.isDesugared()) { + // Below minSdk 24 they are abstract on the device and always reach JS. + expect(Caller.visible(visibleOnly)).toBe("visible js"); + expect(Caller.hidden(hiddenOnly)).toBe("hidden js"); + expect(calls).toEqual(["visible", "hidden"]); + return; + } + + expect(Caller.visible(visibleOnly)).toBe("visible js"); + expect(Caller.hidden(visibleOnly)).toBe("hidden java"); + expect(Caller.narrowed(visibleOnly)).toBe("visible narrowed"); + expect(Caller.hidden(hiddenOnly)).toBe("hidden js"); + expect(Caller.visible(hiddenOnly)).toBe("visible java"); + expect(calls).toEqual(["visible", "hidden"]); + }); + it("reach JS for an interface whose methods are all default methods, unless D8 desugared them", function () { if (sdk < 24) { return; diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/HiddenDefaults.java b/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/HiddenDefaults.java new file mode 100644 index 000000000..ecfdf2d79 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/HiddenDefaults.java @@ -0,0 +1,12 @@ +package com.tns.tests.interfaces.hiddendefaults; + +// Package-private: a class generated in another package cannot name it. +interface HiddenDefaults { + default String hidden() { + return "hidden java"; + } + + default Object narrowed() { + return "hidden narrowed"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaults.java b/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaults.java new file mode 100644 index 000000000..2cb3a07e0 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaults.java @@ -0,0 +1,14 @@ +package com.tns.tests.interfaces.hiddendefaults; + +public interface VisibleDefaults extends HiddenDefaults { + String name(); + + default String visible() { + return "visible java"; + } + + @Override + default String narrowed() { + return "visible narrowed"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaultsCaller.java b/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaultsCaller.java new file mode 100644 index 000000000..3919bc530 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/hiddendefaults/VisibleDefaultsCaller.java @@ -0,0 +1,35 @@ +package com.tns.tests.interfaces.hiddendefaults; + +// Java callers for testInterfaceDefaultMethodOverrides.js: a default inherited from a +// super-interface that classes outside this package cannot access. +public class VisibleDefaultsCaller { + public static String hidden(VisibleDefaults instance) { + try { + return instance.hidden(); + } catch (Throwable t) { + return t.getClass().getName() + ": " + t.getMessage(); + } + } + + public static String visible(VisibleDefaults instance) { + try { + return instance.visible(); + } catch (Throwable t) { + return t.getClass().getName() + ": " + t.getMessage(); + } + } + + // Through the super-interface's Object narrowed(), which the sub-interface narrows. + public static String narrowed(VisibleDefaults instance) { + try { + HiddenDefaults asHidden = instance; + return java.util.Objects.toString(asHidden.narrowed()); + } catch (Throwable t) { + return t.getClass().getName() + ": " + t.getMessage(); + } + } + + public static boolean isDesugared() throws NoSuchMethodException { + return !VisibleDefaults.class.getMethod("visible").isDefault(); + } +} 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 8e8012813..ae3bb2e59 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 @@ -131,6 +131,26 @@ public static String[] names(Class iface) { return names.toArray(new String[0]); } + /** The method of iface's hierarchy whose {@link #key} is key, or null. */ + public static Method find(Class iface, String key) { + Set> visited = new HashSet<>(); + Deque> pending = new ArrayDeque<>(); + pending.add(iface); + while (!pending.isEmpty()) { + Class current = pending.poll(); + if (!visited.add(current)) { + continue; + } + for (Method method : current.getDeclaredMethods()) { + if (key(method).equals(key)) { + return method; + } + } + pending.addAll(Arrays.asList(current.getInterfaces())); + } + return null; + } + /** Identifies a default method to com.tns.Runtime.callInterfaceDefault. */ public static String key(Method method) { StringBuilder key = new StringBuilder(method.getDeclaringClass().getName()).append('.').append(method.getName()).append('('); 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 2810bdca1..c36e99552 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 @@ -276,6 +276,8 @@ private static List namesOf(List methods) { /* * Calls JS when the instance's mask has the bit of the method's name, and otherwise * runs the interface's body through Runtime.callInterfaceDefault, on the calling thread. + * It names the interface the class implements, not the one declaring the method: that + * may be a super-interface this class cannot access. */ private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method defaultMethod, MethodDescriptor method, int bit, String classSignature, String tnsClassSignature) { MethodVisitor mv = cv.visitMethod(org.ow2.asmdex.Opcodes.ACC_PUBLIC, method.getName(), getDexMethodDescriptor(method), null, new String[0]); @@ -298,7 +300,7 @@ private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method mv.visitLabel(javaBody); generateArrayForCallJsArguments(mv, method.getParameterTypes(), thisRegister, classSignature, tnsClassSignature); mv.visitStringInsn(org.ow2.asmdex.Opcodes.INSN_CONST_STRING, 1, DefaultMethods.key(defaultMethod)); - mv.visitTypeInsn(org.ow2.asmdex.Opcodes.INSN_CONST_CLASS, 2, 0, 0, getAsmDescriptor(new ClassInfo(defaultMethod.getDeclaringClass()))); + mv.visitTypeInsn(org.ow2.asmdex.Opcodes.INSN_CONST_CLASS, 2, 0, 0, classSignature); mv.visitMethodInsn(org.ow2.asmdex.Opcodes.INSN_INVOKE_STATIC, runtimeClass, callInterfaceDefaultMethodName, callInterfaceDefaultSignature, new int[] { thisRegister, 2, 1, 0 }); generateReturnFromObject(mv, method.getReturnType(), thisRegister, 1); diff --git a/test-app/runtime/src/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java index 93a9028cb..d1d51610f 100644 --- a/test-app/runtime/src/main/java/com/tns/Runtime.java +++ b/test-app/runtime/src/main/java/com/tns/Runtime.java @@ -1006,26 +1006,21 @@ private static String[] getDefaultMethodNames(String interfaceName) { /* * Called by a generated class's stub of a default method the instance's JS object does * not implement: runs the interface's body on the calling thread. key is - * DefaultMethods.key of the method, which declaringInterface declares. + * DefaultMethods.key of the method, declared by implementedInterface or one of its + * super-interfaces. */ - public static Object callInterfaceDefault(Object receiver, Class declaringInterface, String key, Object[] args) { + public static Object callInterfaceDefault(Object receiver, Class implementedInterface, String key, Object[] args) { Method method = interfaceDefaultMethods.get(key); - if (method == null || method.getDeclaringClass() != declaringInterface) { - method = findInterfaceDefault(declaringInterface, key); + if (method == null || !method.getDeclaringClass().isAssignableFrom(implementedInterface)) { + method = DefaultMethods.find(implementedInterface, key); + if (method == null) { + throw new NoSuchMethodError(key); + } interfaceDefaultMethods.put(key, method); } return invokeInterfaceDefault(receiver, method, args); } - private static Method findInterfaceDefault(Class declaringInterface, String key) { - for (Method method : declaringInterface.getDeclaredMethods()) { - if (DefaultMethods.key(method).equals(key)) { - return method; - } - } - throw new NoSuchMethodError(key); - } - @RuntimeCallable private static String[] getTypeMetadata(String className, int index) throws ClassNotFoundException { Class clazz = classStorageService.retrieveClass(className); 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 c030fcc5f..04afd5e46 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 @@ -224,6 +224,45 @@ public void aNamedInterfaceImplementationStubsOnlyTheGivenDefaults() throws Exce assertFalse(shape.methods.contains("removeV")); } + interface HiddenBase { + default String hidden() { + return "hidden"; + } + + default Object narrowed() { + return "base"; + } + } + + public interface VisibleSub extends HiddenBase { + @Override + default String narrowed() { + return "sub"; + } + } + + private static Method declared(Class clazz, String name, Class returnType) { + for (Method method : clazz.getDeclaredMethods()) { + if (method.getName().equals(name) && method.getReturnType() == returnType && !method.isBridge()) { + return method; + } + } + throw new AssertionError(name); + } + + @Test + public void findResolvesAKeyThroughTheImplementedInterfacesHierarchy() { + Method hidden = declared(HiddenBase.class, "hidden", String.class); + Method baseNarrowed = declared(HiddenBase.class, "narrowed", Object.class); + Method subNarrowed = declared(VisibleSub.class, "narrowed", String.class); + + assertEquals(hidden, DefaultMethods.find(VisibleSub.class, DefaultMethods.key(hidden))); + assertEquals(baseNarrowed, DefaultMethods.find(VisibleSub.class, DefaultMethods.key(baseNarrowed))); + assertEquals(subNarrowed, DefaultMethods.find(VisibleSub.class, DefaultMethods.key(subNarrowed))); + assertEquals(null, DefaultMethods.find(Runnable.class, DefaultMethods.key(hidden))); + assertTrue(DefaultMethods.collect(VisibleSub.class).contains(hidden)); + } + @Test public void generationIsByteStable() { assertArrayEquals(generate(Iterator.class, true), generate(Iterator.class, true)); From 54025b230d6299331359bba43c024bc6aaf78358 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 10:56:13 -0300 Subject: [PATCH 08/16] fix(bindings): key a cached default-overriding dex by the default method names The mask bits of the default-overriding class follow the order of the interface's default method names when the class was generated, while native computes the mask from the names on the running device. The dex cache key changes on every app install, but not when a platform update adds a default method to an interface, and a dex cached under a directory that survives that update would then dispatch shifted bits. Add a hash of the sorted default method names to the class's dex file name, so a dex generated for another list is never loaded. --- .../java/com/tns/bindings/DefaultMethods.java | 18 +++++++++++++ .../java/com/tns/bindings/ProxyGenerator.java | 12 ++++++++- .../src/main/java/com/tns/DexFactory.java | 5 ++++ .../com/tns/bindings/DefaultMethodsTest.java | 27 +++++++++++++++++++ 4 files changed, 61 insertions(+), 1 deletion(-) 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 ae3bb2e59..965457595 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 @@ -131,6 +131,24 @@ public static String[] names(Class iface) { return names.toArray(new String[0]); } + /** 8 hex digits of FNV-1a 32 over the sorted distinct names of the methods. */ + public static String namesHash(List methods) { + TreeSet names = new TreeSet<>(); + for (Method method : methods) { + names.add(method.getName()); + } + int hash = 0x811c9dc5; + for (String name : names) { + for (int i = 0; i < name.length(); i++) { + hash ^= name.charAt(i); + hash *= 0x01000193; + } + hash ^= ','; + hash *= 0x01000193; + } + return String.format("%08x", hash); + } + /** The method of iface's hierarchy whose {@link #key} is key, or null. */ public static Method find(Class iface, String key) { Set> visited = new HashSet<>(); diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java index 1fc1e83a4..f5d08bfa5 100644 --- a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java @@ -68,7 +68,7 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto if (!isInterface) { proxyFileName += Dump.CLASS_NAME_LOCATION_SEPARATOR + proxyName; } else if (defaultMethods != null) { - proxyFileName += Dump.DEFAULT_OVERRIDING_SUFFIX; + proxyFileName += defaultOverridingFileSuffix(defaultMethods); } if (proxyThumb != null) { proxyFileName += "-" + proxyThumb; @@ -87,6 +87,16 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto return proxyPath; } + /* + * The dex file name part after the interface's name for its default-overriding class. + * The class's mask bits follow the order of the interface's default method names, so a + * dex cached for another list (a platform update that adds a default method) must not + * be loaded: the names' hash keeps it from matching. + */ + public static String defaultOverridingFileSuffix(List defaultMethods) { + return Dump.DEFAULT_OVERRIDING_SUFFIX + "-" + DefaultMethods.namesHash(defaultMethods); + } + private String saveProxy(String proxyName, byte[] proxyBytes) throws IOException { File file = new File(path + File.separator + proxyName + ".dex"); File parentDir = file.getParentFile(); 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 d628701b7..561085ff8 100644 --- a/test-app/runtime/src/main/java/com/tns/DexFactory.java +++ b/test-app/runtime/src/main/java/com/tns/DexFactory.java @@ -139,6 +139,11 @@ public Class resolveClass(String baseClassName, String name, String className // strip the `com.tns.gen` off the base extended class name String desiredDexClassName = this.getClassToProxyName(fullClassName); + if (overridesDefaults) { + // The same file name ProxyGenerator writes the class under. + desiredDexClassName = this.getClassToProxyName(className.replace("$", "_")) + + ProxyGenerator.defaultOverridingFileSuffix(DefaultMethods.collect(Class.forName(classToProxy))); + } // A named proxy (`Base.extend('a.b.C', {...})` / @JavaProxy) asks for // exactly that Java class name; the substitutions below are for the 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 04afd5e46..ef46ea139 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 @@ -263,6 +263,33 @@ public void findResolvesAKeyThroughTheImplementedInterfacesHierarchy() { assertTrue(DefaultMethods.collect(VisibleSub.class).contains(hidden)); } + @Test + public void theDefaultOverridingFileNameChangesWithTheDefaultMethodNames() throws Exception { + List iteratorDefaults = DefaultMethods.collect(Iterator.class); + List withoutRemove = new ArrayList<>(iteratorDefaults); + withoutRemove.remove(Iterator.class.getMethod("remove")); + List withAnother = new ArrayList<>(iteratorDefaults); + withAnother.add(Derived.class.getMethod("redefined")); + + String suffix = ProxyGenerator.defaultOverridingFileSuffix(iteratorDefaults); + assertTrue(suffix.startsWith(Dump.DEFAULT_OVERRIDING_SUFFIX + "-")); + assertEquals(suffix, ProxyGenerator.defaultOverridingFileSuffix(new ArrayList<>(iteratorDefaults))); + assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withoutRemove))); + assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withAnother))); + + java.io.File dir = java.nio.file.Files.createTempDirectory("proxies").toFile(); + try { + String path = new ProxyGenerator(dir.getAbsolutePath()).generateProxy("", null, new ClassInfo(Iterator.class), null, + new HashSet(), true, null, iteratorDefaults); + assertEquals("java.util.Iterator" + suffix + ".dex", new java.io.File(path).getName()); + } finally { + for (java.io.File file : dir.listFiles()) { + file.delete(); + } + dir.delete(); + } + } + @Test public void generationIsByteStable() { assertArrayEquals(generate(Iterator.class, true), generate(Iterator.class, true)); From 4240422ecd52fc9f3805669748e859cdf53e0c1f Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 10:56:18 -0300 Subject: [PATCH 09/16] test: pin extend() of a nested interface with a JS default method An anonymous extend of a nested interface whose implementation object defines a default method resolves its default-overriding class, named with '_' where the interface's name has '$', and Java calls the JS implementation. --- .../testInterfaceDefaultMethodOverrides.js | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index d47d5927b..f55594235 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -511,6 +511,24 @@ describe("Interface default methods implemented in JS", function () { expect(F.biNegate(same, "a", "a")).toBe("true|true"); }); + it("are called through an extend of a nested interface", function () { + if (sdk < 24) { + return; + } + var OfDouble = java.util.PrimitiveIterator.OfDouble; + var removes = 0; + var Removing = OfDouble[ext]({ + hasNext: function () { return false; }, + nextDouble: function () { return 0; }, + remove: function () { removes++; } + }); + var removing = new Removing(); + + expect(F.className(removing)).toBe("com.tns.gen.java.util.PrimitiveIterator_OfDouble" + SUFFIX); + expect(F.remove(removing)).toBe("removed"); + expect(removes).toBe(1); + }); + it("run a default declared in a super-interface the generated class cannot access", function () { if (sdk < 24) { return; From 916699e6f825d4f68b7d0f3095bb0e84ac4ddf87 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 11:33:41 -0300 Subject: [PATCH 10/16] fix(bindings): key a cached default-overriding dex by the default method signatures The file name carried a hash of the interface's default method names only, so a platform update that adds an overload of an existing default would not invalidate a cached class, which has no stub for the new overload. The hash now covers each method's declaring interface, name, parameter and return types. --- .../main/java/com/tns/bindings/DefaultMethods.java | 14 +++++++------- .../main/java/com/tns/bindings/ProxyGenerator.java | 8 ++++---- .../java/com/tns/bindings/DefaultMethodsTest.java | 3 +++ 3 files changed, 14 insertions(+), 11 deletions(-) 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 965457595..b405b530a 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 @@ -131,16 +131,16 @@ public static String[] names(Class iface) { return names.toArray(new String[0]); } - /** 8 hex digits of FNV-1a 32 over the sorted distinct names of the methods. */ - public static String namesHash(List methods) { - TreeSet names = new TreeSet<>(); + /** 8 hex digits of FNV-1a 32 over the sorted keys of the methods. */ + public static String signaturesHash(List methods) { + TreeSet keys = new TreeSet<>(); for (Method method : methods) { - names.add(method.getName()); + keys.add(key(method)); } int hash = 0x811c9dc5; - for (String name : names) { - for (int i = 0; i < name.length(); i++) { - hash ^= name.charAt(i); + for (String key : keys) { + for (int i = 0; i < key.length(); i++) { + hash ^= key.charAt(i); hash *= 0x01000193; } hash ^= ','; diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java index f5d08bfa5..69c6392c5 100644 --- a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java @@ -89,12 +89,12 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto /* * The dex file name part after the interface's name for its default-overriding class. - * The class's mask bits follow the order of the interface's default method names, so a - * dex cached for another list (a platform update that adds a default method) must not - * be loaded: the names' hash keeps it from matching. + * The class stubs exactly these methods, and its mask bits follow the order of their + * names, so a dex cached for another list (a platform update that adds a default method + * or an overload of one) must not be loaded: the methods' hash keeps it from matching. */ public static String defaultOverridingFileSuffix(List defaultMethods) { - return Dump.DEFAULT_OVERRIDING_SUFFIX + "-" + DefaultMethods.namesHash(defaultMethods); + return Dump.DEFAULT_OVERRIDING_SUFFIX + "-" + DefaultMethods.signaturesHash(defaultMethods); } private String saveProxy(String proxyName, byte[] proxyBytes) throws IOException { 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 ef46ea139..fde0cb146 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 @@ -276,6 +276,9 @@ public void theDefaultOverridingFileNameChangesWithTheDefaultMethodNames() throw assertEquals(suffix, ProxyGenerator.defaultOverridingFileSuffix(new ArrayList<>(iteratorDefaults))); assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withoutRemove))); assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withAnother))); + List withOverload = new ArrayList<>(iteratorDefaults); + withOverload.add(java.util.PrimitiveIterator.OfInt.class.getMethod("forEachRemaining", java.util.function.IntConsumer.class)); + assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withOverload))); java.io.File dir = java.nio.file.Files.createTempDirectory("proxies").toFile(); try { From 8a7453a0da3cb8f2762c23d6cb9005f8b03f6247 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 13:50:37 -0300 Subject: [PATCH 11/16] fix(bindings): leave a default a sub-interface bridges to the bridge A narrowed generic default, such as same(String) overriding a super-interface's same(Object), comes with a bridge same(Object) in the narrowing interface. Stubbing the super-interface's same(Object) as well ran its body directly for calls through the erased signature, skipping the bridge and the narrowed default. --- .../testInterfaceDefaultMethodOverrides.js | 31 +++++++++++++ .../interfaces/defaultshapes/Shapes.java | 46 +++++++++++++++++++ .../defaultshapes/ShapesCaller.java | 31 +++++++++++++ .../defaultshapes/ShapesException.java | 7 +++ .../defaultshapes/StringShapes.java | 9 ++++ .../java/com/tns/bindings/DefaultMethods.java | 30 +++++++++++- .../com/tns/bindings/DefaultMethodsTest.java | 26 +++++++++++ 7 files changed, 178 insertions(+), 2 deletions(-) create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/Shapes.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesCaller.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesException.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/StringShapes.java diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index f55594235..cbe6e2d4f 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -594,4 +594,35 @@ describe("Interface default methods implemented in JS", function () { var onlyText = new L({ onText: function () {} }); expect(F.describeOnBackgroundThread(onlyText, 5000)).toBe("java default on " + F.CALLER_THREAD); }, 15000); + + it("run the Java bodies of defaults of every argument and return kind", function () { + if (sdk < 24) { + return; + } + var D = com.tns.tests.interfaces.defaultshapes; + if (D.ShapesCaller.isDesugared()) { + // Below minSdk 24 every method is abstract on the device. + return; + } + var odd = []; + var shapes = new D.Shapes({ + name: function () { return "js"; }, + odd: function (value) { + odd.push(value); + return false; + } + }); + + expect(F.className(shapes)).toBe("com.tns.gen.com.tns.tests.interfaces.defaultshapes.Shapes" + SUFFIX); + expect(D.ShapesCaller.all(shapes)).toBe("7028|2.5|0.5|Q|false|-4|42|js:9223372036854775807:-0.25|v"); + expect(odd).toEqual([3]); + expect(D.ShapesCaller.fail(shapes)).toBe("com.tns.tests.interfaces.defaultshapes.ShapesException: from java"); + + // same(Object), the bridge, reaches the narrowed default through the stub. + var strings = new D.StringShapes({ + name: function () { return "s"; }, + odd: function () { return true; } + }); + expect(D.ShapesCaller.all(strings)).toBe("7028|2.5|0.5|Q|true|-4|42|s:9223372036854775807:-0.25|string v"); + }); }); diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/Shapes.java b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/Shapes.java new file mode 100644 index 000000000..05022d729 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/Shapes.java @@ -0,0 +1,46 @@ +package com.tns.tests.interfaces.defaultshapes; + +// Default methods of every argument and return kind, for testInterfaceDefaultMethodOverrides.js. +public interface Shapes { + String name(); + + default long wide(long a, double b, int c) { + return a * 1000 + (long) (b * 10) + c; + } + + default double half(long value) { + return value / 2.0; + } + + default float third(float value) { + return value / 3f; + } + + default char upper(char value) { + return Character.toUpperCase(value); + } + + default boolean odd(int value) { + return (value & 1) != 0; + } + + default byte negated(byte value) { + return (byte) -value; + } + + default short doubled(short value) { + return (short) (value * 2); + } + + default void record(StringBuilder out, long value, double fraction) { + out.append(name()).append(':').append(value).append(':').append(fraction); + } + + default T same(T value) { + return value; + } + + default String fail(String message) throws ShapesException { + throw new ShapesException(message); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesCaller.java b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesCaller.java new file mode 100644 index 000000000..39b090e6e --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesCaller.java @@ -0,0 +1,31 @@ +package com.tns.tests.interfaces.defaultshapes; + +// Java callers for testInterfaceDefaultMethodOverrides.js. Each reports a value or the +// exception's class and message as text. +public class ShapesCaller { + public static String all(Shapes shapes) { + StringBuilder out = new StringBuilder(); + out.append(shapes.wide(7, 2.5, 3)).append('|'); + out.append(shapes.half(5)).append('|'); + out.append(shapes.third(1.5f)).append('|'); + out.append(shapes.upper('q')).append('|'); + out.append(shapes.odd(3)).append('|'); + out.append(shapes.negated((byte) 4)).append('|'); + out.append(shapes.doubled((short) 21)).append('|'); + shapes.record(out, Long.MAX_VALUE, -0.25); + out.append('|').append(shapes.same("v")); + return out.toString(); + } + + public static String fail(Shapes shapes) { + try { + return shapes.fail("from java"); + } catch (Throwable t) { + return t.getClass().getName() + ": " + t.getMessage(); + } + } + + public static boolean isDesugared() throws NoSuchMethodException { + return !Shapes.class.getMethod("half", long.class).isDefault(); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesException.java b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesException.java new file mode 100644 index 000000000..ff601f05e --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/ShapesException.java @@ -0,0 +1,7 @@ +package com.tns.tests.interfaces.defaultshapes; + +public class ShapesException extends Exception { + public ShapesException(String message) { + super(message); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/StringShapes.java b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/StringShapes.java new file mode 100644 index 000000000..c19d0375e --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/defaultshapes/StringShapes.java @@ -0,0 +1,9 @@ +package com.tns.tests.interfaces.defaultshapes; + +// Narrows the generic default; javac adds the bridge same(Object) that forwards to it. +public interface StringShapes extends Shapes { + @Override + default String same(String value) { + return "string " + value; + } +} 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 b405b530a..5c35aaef6 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 @@ -61,6 +61,7 @@ private static String signature(Method method) { private static List collect(Collection> roots, Set excludedSignatures) { Map> declarationsBySignature = new LinkedHashMap<>(); + List bridges = new ArrayList<>(); Set> visited = new HashSet<>(); Deque> pending = new ArrayDeque<>(roots); while (!pending.isEmpty()) { @@ -70,7 +71,14 @@ private static List collect(Collection> roots, Set excl } for (Method method : current.getDeclaredMethods()) { int modifiers = method.getModifiers(); - if (Modifier.isStatic(modifiers) || !Modifier.isPublic(modifiers) || method.isSynthetic() || method.isBridge()) { + if (Modifier.isStatic(modifiers) || !Modifier.isPublic(modifiers)) { + continue; + } + if (method.isBridge()) { + bridges.add(method); + continue; + } + if (method.isSynthetic()) { continue; } String signature = signature(method); @@ -107,7 +115,7 @@ private static List collect(Collection> roots, Set excl } // Several maximal declarations conflict, and the class must override them // itself; that case keeps whatever it does without this class. - if (maximal == 1 && mostSpecific.isDefault()) { + if (maximal == 1 && mostSpecific.isDefault() && !isBridged(mostSpecific, bridges)) { result.add(mostSpecific); } } @@ -122,6 +130,24 @@ public int compare(Method a, Method b) { return result; } + /* + * 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 + * to the narrowed method the sub-interface declares, so the method itself must not be stubbed. + */ + private static boolean isBridged(Method method, List bridges) { + for (Method bridge : bridges) { + if (bridge.getDeclaringClass() != method.getDeclaringClass() + && method.getDeclaringClass().isAssignableFrom(bridge.getDeclaringClass()) + && bridge.getName().equals(method.getName()) + && bridge.getReturnType() == method.getReturnType() + && Arrays.equals(bridge.getParameterTypes(), method.getParameterTypes())) { + return true; + } + } + return false; + } + /** Sorted distinct names of {@link #collect}; a name's index is its bit. */ public static String[] names(Class iface) { TreeSet names = new TreeSet<>(); 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 fde0cb146..ba79fa3ee 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 @@ -111,6 +111,32 @@ public void collectsTheOverridingDeclarationAndNoBridges() throws Exception { assertEquals(Integer.class, Covariant.class.getMethod("next").getReturnType()); } + interface Generic { + default T same(T value) { + return value; + } + } + + // javac adds the bridge same(Object), which forwards to same(String). + interface Narrowing extends Generic { + @Override + default String same(String value) { + return "narrowed " + value; + } + } + + @Test + public void leavesADefaultAMoreSpecificBridgeOverridesToTheBridge() throws Exception { + Method erased = Generic.class.getMethod("same", Object.class); + assertTrue(Narrowing.class.getDeclaredMethod("same", Object.class).isBridge()); + + List narrowing = DefaultMethods.collect(Narrowing.class); + assertEquals(Arrays.asList(Narrowing.class.getMethod("same", String.class)), narrowing); + assertFalse(narrowing.contains(erased)); + assertEquals(Arrays.asList(erased), DefaultMethods.collect(Generic.class)); + assertArrayEquals(new String[]{"same"}, DefaultMethods.names(Narrowing.class)); + } + static class Implementor implements Derived { @Override public String reabstracted() { From d876c0f7cdc7bef858e260a59047942319e5c296 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 11:47:36 -0300 Subject: [PATCH 12/16] feat(asmdex): choose the dex format version per writer A writer can emit dex 037, the first version whose code may reference interface methods with invoke-super. The reader accepts it too. --- .../org/ow2/asmdex/ApplicationWriter.java | 30 ++++++++++++++++++- .../lowLevelUtils/BasicDexFileReader.java | 6 +++- 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/ApplicationWriter.java b/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/ApplicationWriter.java index 8150f356a..1ea6ab444 100644 --- a/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/ApplicationWriter.java +++ b/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/ApplicationWriter.java @@ -168,10 +168,20 @@ public class ApplicationWriter extends ApplicationVisitor { private int classDataItemCount = 0; // Global count of the class_data_items in the data section. private int codeItemCount; // Count of the Code Items of this application. + /** The dex format version a writer uses unless it is given another. */ + public static final int DEFAULT_DEX_VERSION = 35; + + /** + * The first dex format version whose files may reference interface methods with + * invoke-super, as the code of default methods does. Android 7.0 (API 24) and later + * load it. + */ + public static final int DEFAULT_METHODS_DEX_VERSION = 37; + /** * The Dex_File_Magic number. */ - private static final byte[] dexFileMagic = new byte[] {0x64, 0x65, 0x78, 0xa, 0x30, 0x33, 0x35, 0x00 }; + private final byte[] dexFileMagic; private static final int ADLER_OFFSET = 8; // offset in bytes of the Adler32 Checksum. private static final int ADLER_SIZE = 4; // Size in bytes of the Adler32 Checksum. @@ -198,7 +208,24 @@ public class ApplicationWriter extends ApplicationVisitor { * Constructs an new {@link ClassWriter}. */ public ApplicationWriter() { + this(DEFAULT_DEX_VERSION); + } + + /** + * Constructs a writer of dex files of the given format version (35, 37, ...). The + * writer emits whatever it is given; the version only states which runtimes may load it. + */ + public ApplicationWriter(int dexVersion) { super(Opcodes.ASM4); + this.dexFileMagic = dexFileMagic(dexVersion); + } + + private static byte[] dexFileMagic(int dexVersion) { + if (dexVersion < 0 || dexVersion > 999) { + throw new IllegalArgumentException("dex version " + dexVersion); + } + return new byte[] {0x64, 0x65, 0x78, 0xa, + (byte) ('0' + dexVersion / 100), (byte) ('0' + dexVersion / 10 % 10), (byte) ('0' + dexVersion % 10), 0x00 }; } /** @@ -224,6 +251,7 @@ public ApplicationWriter() { */ public ApplicationWriter(final ApplicationReader applicationReader) { super(Opcodes.ASM4); + this.dexFileMagic = dexFileMagic(DEFAULT_DEX_VERSION); applicationReader.copyPool(this); this.applicationReader = applicationReader; } diff --git a/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/lowLevelUtils/BasicDexFileReader.java b/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/lowLevelUtils/BasicDexFileReader.java index cc04cff5a..d41f91e52 100644 --- a/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/lowLevelUtils/BasicDexFileReader.java +++ b/test-app/runtime-binding-generator/src/main/java/org/ow2/asmdex/lowLevelUtils/BasicDexFileReader.java @@ -57,6 +57,10 @@ public class BasicDexFileReader { private static final byte[] MAGIC_TEMPLATE = { 0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x35, 0x00 }; + // 037 differs from 035 only in what the code may reference, not in the file's layout. + private static final byte[] MAGIC_TEMPLATE_037 = + { 0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x37, 0x00 }; + // Offset of the format version number in the sequence above. private static final int OFFSET_FORMAT_VERSION_NUMBER_IN_MAGIC_SEQUENCE = 4; private static final int LENGTH_FORMAT_VERSION_NUMBER_IN_MAGIC_SEQUENCE = 3; @@ -193,7 +197,7 @@ public void parse(byte[] dexBytes) throws IllegalArgumentException, IOException protected void readHeader() throws IllegalArgumentException { // Checks the Magic sequence at offset 0. reader.bytes(magic); - if (!Arrays.equals(magic, MAGIC_TEMPLATE)) { + if (!Arrays.equals(magic, MAGIC_TEMPLATE) && !Arrays.equals(magic, MAGIC_TEMPLATE_037)) { throw new IllegalArgumentException("Unknown bytecode version"); } From 9135ab822519fe735d837dc0140073e3548fc706 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 13:58:25 -0300 Subject: [PATCH 13/16] perf(bindings): run the defaults a JS object lacks with invoke-super A default-overriding class whose JS object does not implement a default now runs the interface's body with invoke-super/range naming the interface it implements, with typed moves and returns, instead of boxing the arguments for Runtime.callInterfaceDefault and calling it non-virtually through JNI: a few ns per call instead of hundreds. The class is written as dex 037 together with a probe class that calls defaults of boot class path interfaces the same way. The first such class a process loads runs its probe, once; if the probe fails, that and every later default-overriding class of the process uses the JNI stubs instead, under the -defaults-jni name. --- .../com/tns/bindings/DefaultMethodBodies.java | 28 ++ .../com/tns/bindings/DefaultSuperProbe.java | 257 ++++++++++++++++++ .../src/main/java/com/tns/bindings/Dump.java | 63 ++++- .../java/com/tns/bindings/ProxyGenerator.java | 23 +- .../main/java/com/tns/DefaultSuperCalls.java | 63 +++++ .../src/main/java/com/tns/DexFactory.java | 33 ++- .../com/tns/bindings/DefaultMethodsTest.java | 13 +- .../tns/bindings/DefaultSuperBodiesTest.java | 191 +++++++++++++ 8 files changed, 644 insertions(+), 27 deletions(-) create mode 100644 test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethodBodies.java create mode 100644 test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultSuperProbe.java create mode 100644 test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java create mode 100644 test-app/runtime/src/test/java/com/tns/bindings/DefaultSuperBodiesTest.java diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethodBodies.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethodBodies.java new file mode 100644 index 000000000..a6289f633 --- /dev/null +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethodBodies.java @@ -0,0 +1,28 @@ +package com.tns.bindings; + +import org.ow2.asmdex.ApplicationWriter; + +/** + * How a default-overriding class runs the Java body of a default method its JS object does + * not implement. The two kinds of class have different names, so that one of each can be + * loaded for the same interface. + */ +public enum DefaultMethodBodies { + /** + * With invoke-super naming the interface the class implements. The class's dex file also + * holds its DefaultSuperProbe class, which has to pass before the class is used. + */ + INVOKE_SUPER(ApplicationWriter.DEFAULT_METHODS_DEX_VERSION, Dump.DEFAULT_OVERRIDING_SUFFIX), + /** Through com.tns.Runtime.callInterfaceDefault, which calls the method non-virtually with JNI. */ + RUNTIME_CALL(ApplicationWriter.DEFAULT_DEX_VERSION, Dump.DEFAULT_OVERRIDING_SUFFIX + "-jni"); + + /** The dex format version of a file holding such a class. */ + public final int dexVersion; + /** Appended to the interface's generated class name to name such a class. */ + public final String classSuffix; + + DefaultMethodBodies(int dexVersion, String classSuffix) { + this.dexVersion = dexVersion; + this.classSuffix = classSuffix; + } +} diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultSuperProbe.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultSuperProbe.java new file mode 100644 index 000000000..0827de846 --- /dev/null +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultSuperProbe.java @@ -0,0 +1,257 @@ +package com.tns.bindings; + +import java.lang.reflect.Field; +import java.util.Comparator; +import java.util.Iterator; +import java.util.function.Consumer; + +import org.ow2.asmdex.ApplicationWriter; +import org.ow2.asmdex.ClassVisitor; +import org.ow2.asmdex.FieldVisitor; +import org.ow2.asmdex.MethodVisitor; +import org.ow2.asmdex.Opcodes; +import org.ow2.asmdex.structureCommon.Label; + +/** + * A class whose methods call default methods of boot class path interfaces with invoke-super, + * the way a default-overriding class runs the defaults its JS object does not implement, and + * the checks that tell whether the runtime executed them correctly. Its interfaces are + * java.util.PrimitiveIterator.OfInt and java.util.Comparator: + *
    + *
  • remove() is declared by Iterator, a super-interface of OfInt;
  • + *
  • next() is OfInt's covariant redeclaration of Iterator.next(), returning Integer;
  • + *
  • forEachRemaining(Consumer) is OfInt's default, which calls back into hasNext();
  • + *
  • reversed() returns an object that calls back into compare().
  • + *
+ * Every such method fails with IllegalStateException when it is entered again before it + * returned, so an invoke-super that dispatches back to the class shows up as a failed check + * rather than as unbounded recursion. + */ +public final class DefaultSuperProbe { + static final int NEXT_INT = 42; + static final int COMPARE = 7; + + private static final String OBJECT = "Ljava/lang/Object;"; + private static final String OF_INT = "Ljava/util/PrimitiveIterator$OfInt;"; + private static final String COMPARATOR = "Ljava/util/Comparator;"; + private static final String ILLEGAL_STATE = "Ljava/lang/IllegalStateException;"; + + private static final String ENTERED = "entered"; + private static final String HAS_NEXT_CALLS = "hasNextCalls"; + + private DefaultSuperProbe() { + } + + /** The descriptor the probe gets in the dex file of a default-overriding class. */ + public static String descriptor(String defaultOverridingDescriptor) { + return defaultOverridingDescriptor.substring(0, defaultOverridingDescriptor.length() - 1) + "-probe;"; + } + + /** The name the probe gets in the dex file of a default-overriding class. */ + public static String className(String defaultOverridingClassName) { + return defaultOverridingClassName + "-probe"; + } + + /** + * Adds the probe class, named by its dex descriptor ("Lcom/x/Y;"), to aw. Like a + * default-overriding class's stubs, its invoke-super instructions name the interface the + * class implements, also for remove(), which Iterator declares. + */ + public static void generate(ApplicationWriter aw, String descriptor) { + String[] interfaces = { OF_INT, COMPARATOR }; + ClassVisitor cv = aw.visitClass(Opcodes.ACC_PUBLIC, descriptor, null, OBJECT, interfaces); + cv.visit(0, Opcodes.ACC_PUBLIC, descriptor, null, OBJECT, interfaces); + + FieldVisitor fv = cv.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, ENTERED, "Z", null, null); + fv.visitEnd(); + fv = cv.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, HAS_NEXT_CALLS, "I", null, null); + fv.visitEnd(); + + generateConstructor(cv); + generateHasNext(cv, descriptor); + generateConstant(cv, "nextInt", "I", 0, NEXT_INT); + generateConstant(cv, "compare", "I" + OBJECT + OBJECT, 2, COMPARE); + + generateSuperCall(cv, descriptor, OF_INT, "remove", "V", 0, Opcodes.INSN_RETURN_VOID); + generateSuperCall(cv, descriptor, OF_INT, "next", "Ljava/lang/Integer;", 0, Opcodes.INSN_RETURN_OBJECT); + generateSuperCall(cv, descriptor, OF_INT, "forEachRemaining", "VLjava/util/function/Consumer;", 1, Opcodes.INSN_RETURN_VOID); + generateSuperCall(cv, descriptor, COMPARATOR, "reversed", COMPARATOR, 0, Opcodes.INSN_RETURN_OBJECT); + + cv.visitEnd(); + } + + private static void generateConstructor(ClassVisitor cv) { + MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_CONSTRUCTOR, "", "V", null, null); + mv.visitCode(); + mv.visitMaxs(1, 0); + mv.visitMethodInsn(Opcodes.INSN_INVOKE_DIRECT, OBJECT, "", "V", new int[] { 0 }); + mv.visitInsn(Opcodes.INSN_RETURN_VOID); + mv.visitEnd(); + } + + private static void generateHasNext(ClassVisitor cv, String descriptor) { + MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC, "hasNext", "Z", null, null); + mv.visitCode(); + mv.visitMaxs(2, 0); + mv.visitFieldInsn(Opcodes.INSN_SGET, descriptor, HAS_NEXT_CALLS, "I", 0, 0); + mv.visitOperationInsn(Opcodes.INSN_ADD_INT_LIT8, 0, 0, 0, 1); + mv.visitFieldInsn(Opcodes.INSN_SPUT, descriptor, HAS_NEXT_CALLS, "I", 0, 0); + mv.visitVarInsn(Opcodes.INSN_CONST_4, 0, 0); + mv.visitIntInsn(Opcodes.INSN_RETURN, 0); + mv.visitEnd(); + } + + private static void generateConstant(ClassVisitor cv, String name, String desc, int parameterWords, int value) { + MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC, name, desc, null, null); + mv.visitCode(); + mv.visitMaxs(1 + 1 + parameterWords, 0); + mv.visitVarInsn(Opcodes.INSN_CONST_16, 0, value); + mv.visitIntInsn(Opcodes.INSN_RETURN, 0); + mv.visitEnd(); + } + + // v0-v2 are locals, v3 is this and the parameters follow it. + private static void generateSuperCall(ClassVisitor cv, String descriptor, String owner, String name, String desc, int parameterWords, int returnOpcode) { + MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC, name, desc, null, null); + mv.visitCode(); + int thisRegister = 3; + mv.visitMaxs(thisRegister + 1 + parameterWords, 0); + + Label start = new Label(); + Label end = new Label(); + Label handler = new Label(); + Label enter = new Label(); + mv.visitTryCatchBlock(start, end, handler, null); + + mv.visitFieldInsn(Opcodes.INSN_SGET_BOOLEAN, descriptor, ENTERED, "Z", 0, 0); + mv.visitJumpInsn(Opcodes.INSN_IF_EQZ, enter, 0, 0); + mv.visitTypeInsn(Opcodes.INSN_NEW_INSTANCE, 0, 0, 0, ILLEGAL_STATE); + mv.visitStringInsn(Opcodes.INSN_CONST_STRING, 1, "re-entered " + name); + mv.visitMethodInsn(Opcodes.INSN_INVOKE_DIRECT, ILLEGAL_STATE, "", "VLjava/lang/String;", new int[] { 0, 1 }); + mv.visitIntInsn(Opcodes.INSN_THROW, 0); + + mv.visitLabel(enter); + mv.visitVarInsn(Opcodes.INSN_CONST_4, 0, 1); + mv.visitFieldInsn(Opcodes.INSN_SPUT_BOOLEAN, descriptor, ENTERED, "Z", 0, 0); + mv.visitLabel(start); + int[] arguments = new int[1 + parameterWords]; + for (int i = 0; i < arguments.length; i++) { + arguments[i] = thisRegister + i; + } + mv.visitMethodInsn(Opcodes.INSN_INVOKE_SUPER_RANGE, owner, name, desc, arguments); + mv.visitLabel(end); + if (returnOpcode == Opcodes.INSN_RETURN_OBJECT) { + mv.visitIntInsn(Opcodes.INSN_MOVE_RESULT_OBJECT, 0); + } + mv.visitVarInsn(Opcodes.INSN_CONST_4, 2, 0); + mv.visitFieldInsn(Opcodes.INSN_SPUT_BOOLEAN, descriptor, ENTERED, "Z", 2, 0); + if (returnOpcode == Opcodes.INSN_RETURN_VOID) { + mv.visitInsn(returnOpcode); + } else { + mv.visitIntInsn(returnOpcode, 0); + } + + mv.visitLabel(handler); + mv.visitIntInsn(Opcodes.INSN_MOVE_EXCEPTION, 0); + mv.visitVarInsn(Opcodes.INSN_CONST_4, 2, 0); + mv.visitFieldInsn(Opcodes.INSN_SPUT_BOOLEAN, descriptor, ENTERED, "Z", 2, 0); + mv.visitIntInsn(Opcodes.INSN_THROW, 0); + mv.visitEnd(); + } + + /** The outcome of one call into a probe instance. */ + public static final class Call { + public final String name; + /** Whether the default ran the interface's body and returned what it should. */ + public final boolean passed; + public final String detail; + + Call(String name, boolean passed, String detail) { + this.name = name; + this.passed = passed; + this.detail = detail; + } + + @Override + public String toString() { + return name + (passed ? " ok " : " FAILED ") + detail; + } + } + + /** + * Creates and initializes the probe class (a verification failure surfaces here as a + * LinkageError), then makes each of its default calls once. + */ + public static Call[] check(Class probeClass) throws ReflectiveOperationException { + Object probe = probeClass.getConstructor().newInstance(); + Field hasNextCalls = probeClass.getField(HAS_NEXT_CALLS); + return new Call[] { + remove(probe), + next(probe), + forEachRemaining(probe, hasNextCalls), + reversed(probe) + }; + } + + /** Whether every call of {@link #check} passed. */ + public static boolean passed(Call[] calls) { + for (Call call : calls) { + if (!call.passed) { + return false; + } + } + return true; + } + + private static Call remove(Object probe) { + try { + ((Iterator) probe).remove(); + return new Call("remove", false, "returned"); + } catch (Throwable e) { + boolean passed = e.getClass() == UnsupportedOperationException.class; + return new Call("remove", passed, describe(e)); + } + } + + private static Call next(Object probe) { + try { + Object next = ((Iterator) probe).next(); + return new Call("next", Integer.valueOf(NEXT_INT).equals(next), String.valueOf(next)); + } catch (Throwable e) { + return new Call("next", false, describe(e)); + } + } + + private static Call forEachRemaining(Object probe, Field hasNextCalls) { + try { + int before = hasNextCalls.getInt(null); + final int[] accepted = new int[1]; + ((Iterator) probe).forEachRemaining(new Consumer() { + @Override + public void accept(Object o) { + accepted[0]++; + } + }); + int calls = hasNextCalls.getInt(null) - before; + return new Call("forEachRemaining", calls == 1 && accepted[0] == 0, "hasNext calls " + calls); + } catch (Throwable e) { + return new Call("forEachRemaining", false, describe(e)); + } + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private static Call reversed(Object probe) { + try { + Comparator reversed = ((Comparator) probe).reversed(); + int result = reversed.compare("a", "b"); + boolean passed = reversed != probe && result == COMPARE; + return new Call("reversed", passed, (reversed == null ? "null" : reversed.getClass().getName()) + " compare " + result); + } catch (Throwable e) { + return new Call("reversed", false, describe(e)); + } + } + + private static String describe(Throwable e) { + return e.getClass().getName() + ": " + e.getMessage(); + } +} 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 c36e99552..f8c248fb6 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 @@ -186,6 +186,15 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto * 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); + } + + /** + * As above; a default-overriding class runs the Java bodies of the defaults its JS object + * does not implement as bodies says, and its name ends with bodies.classSuffix. aw has to + * write bodies.dexVersion. + */ + public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescriptor classTo, HashSet methodOverrides, HashSet implementedInterfaces, AnnotationDescriptor[] annotations, List defaultMethods, DefaultMethodBodies bodies) { String classSignature = getAsmDescriptor(classTo); boolean overridesDefaults = defaultMethods != null && classTo.isInterface() && !proxyName.contains("."); @@ -199,7 +208,7 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto if (!classTo.isInterface()) { tnsClassSignature += CLASS_NAME_LOCATION_SEPARATOR + proxyName; } else if (overridesDefaults) { - tnsClassSignature += DEFAULT_OVERRIDING_SUFFIX; + tnsClassSignature += bodies.classSuffix; } tnsClassSignature += ";"; @@ -227,12 +236,18 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto generateMethods(cv, classTo, methods, classSignature, tnsClassSignature); if (overridesDefaults) { - generateDefaultMethodStubs(cv, defaultMethods, methods, classSignature, tnsClassSignature); + generateDefaultMethodStubs(cv, defaultMethods, methods, classSignature, tnsClassSignature, bodies); } cv.visitEnd(); } + /** The dex descriptor of the default-overriding class Dump generates for the interface. */ + public static String defaultOverridingDescriptor(ClassDescriptor iface, DefaultMethodBodies bodies) { + String classSignature = getAsmDescriptor(iface); + return LCOM_TNS + classSignature.substring(1, classSignature.length() - 1).replace("$", "_") + bodies.classSuffix + ";"; + } + private MethodDescriptor[] withInheritedDefaults(MethodDescriptor[] methods, List defaultMethods) { List result = new ArrayList(Arrays.asList(methods)); Set signatures = new HashSet(); @@ -248,7 +263,7 @@ private MethodDescriptor[] withInheritedDefaults(MethodDescriptor[] methods, Lis return result.toArray(new MethodDescriptor[result.size()]); } - private void generateDefaultMethodStubs(ClassVisitor cv, List defaultMethods, MethodDescriptor[] generatedMethods, String classSignature, String tnsClassSignature) { + 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)); @@ -261,7 +276,7 @@ private void generateDefaultMethodStubs(ClassVisitor cv, List= DefaultMethods.MAX_DISPATCHED_NAMES || !generatedSignatures.add(method.getName() + "_" + getMethodOverloadDescriptor(method))) { continue; } - generateDefaultMethodStub(cv, defaultMethod, method, bit, classSignature, tnsClassSignature); + generateDefaultMethodStub(cv, defaultMethod, method, bit, classSignature, tnsClassSignature, bodies); } } @@ -275,11 +290,11 @@ private static List namesOf(List methods) { /* * Calls JS when the instance's mask has the bit of the method's name, and otherwise - * runs the interface's body through Runtime.callInterfaceDefault, on the calling thread. - * It names the interface the class implements, not the one declaring the method: that - * may be a super-interface this class cannot access. + * runs the interface's body, on the calling thread. Either way it names the interface the + * class implements, not the one declaring the method: that may be a super-interface this + * class cannot access. */ - private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method defaultMethod, MethodDescriptor method, int bit, String classSignature, String tnsClassSignature) { + private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method defaultMethod, MethodDescriptor method, int bit, String classSignature, String tnsClassSignature, DefaultMethodBodies bodies) { MethodVisitor mv = cv.visitMethod(org.ow2.asmdex.Opcodes.ACC_PUBLIC, method.getName(), getDexMethodDescriptor(method), null, new String[0]); mv.visitCode(); @@ -298,6 +313,11 @@ private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method generateReturnFromObject(mv, method.getReturnType(), thisRegister, 1); mv.visitLabel(javaBody); + if (bodies == DefaultMethodBodies.INVOKE_SUPER) { + generateSuperCall(mv, method, thisRegister, classSignature); + mv.visitEnd(); + return; + } generateArrayForCallJsArguments(mv, method.getParameterTypes(), thisRegister, classSignature, tnsClassSignature); mv.visitStringInsn(org.ow2.asmdex.Opcodes.INSN_CONST_STRING, 1, DefaultMethods.key(defaultMethod)); mv.visitTypeInsn(org.ow2.asmdex.Opcodes.INSN_CONST_CLASS, 2, 0, 0, classSignature); @@ -307,6 +327,33 @@ private void generateDefaultMethodStub(ClassVisitor cv, java.lang.reflect.Method mv.visitEnd(); } + // The arguments are this method's own, in the contiguous registers from thisRegister on. + private void generateSuperCall(MethodVisitor mv, MethodDescriptor method, int thisRegister, String interfaceSignature) { + int words = 1; + for (ClassDescriptor parameterType : method.getParameterTypes()) { + words += parameterType.equals(ClassDescriptor.LONG) || parameterType.equals(ClassDescriptor.DOUBLE) ? 2 : 1; + } + int[] arguments = new int[words]; + for (int i = 0; i < words; i++) { + arguments[i] = thisRegister + i; + } + mv.visitMethodInsn(org.ow2.asmdex.Opcodes.INSN_INVOKE_SUPER_RANGE, interfaceSignature, method.getName(), getDexMethodDescriptor(method), arguments); + + ClassDescriptor returnType = method.getReturnType(); + if (returnType.equals(ClassDescriptor.VOID)) { + mv.visitInsn(org.ow2.asmdex.Opcodes.INSN_RETURN_VOID); + } else if (returnType.equals(ClassDescriptor.LONG) || returnType.equals(ClassDescriptor.DOUBLE)) { + mv.visitIntInsn(org.ow2.asmdex.Opcodes.INSN_MOVE_RESULT_WIDE, 0); + mv.visitIntInsn(org.ow2.asmdex.Opcodes.INSN_RETURN_WIDE, 0); + } else if (returnType.isPrimitive()) { + mv.visitIntInsn(org.ow2.asmdex.Opcodes.INSN_MOVE_RESULT, 0); + mv.visitIntInsn(org.ow2.asmdex.Opcodes.INSN_RETURN, 0); + } else { + mv.visitIntInsn(org.ow2.asmdex.Opcodes.INSN_MOVE_RESULT_OBJECT, 0); + mv.visitIntInsn(org.ow2.asmdex.Opcodes.INSN_RETURN_OBJECT, 0); + } + } + private MethodDescriptor[] groupMethodsByNameAndSignature(MethodDescriptor[] methods) { HashMap result = new HashMap(); for (int i = 0; i < methods.length; i++) { diff --git a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java index 69c6392c5..376485096 100644 --- a/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/ProxyGenerator.java @@ -44,10 +44,23 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto /** defaultMethods: see Dump.generateProxy. */ public String generateProxy(String proxyName, String cacheDigest, ClassDescriptor classToProxy, HashSet methodOverrides, HashSet implementedInterfaces, boolean isInterface, AnnotationDescriptor[] annotations, List defaultMethods) throws IOException { - ApplicationWriter aw = new ApplicationWriter(); + return generateProxy(proxyName, cacheDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, annotations, defaultMethods, DefaultMethodBodies.INVOKE_SUPER); + } + + /** + * bodies: see Dump.generateProxy. With INVOKE_SUPER, a default-overriding class's dex + * file also holds its DefaultSuperProbe class. + */ + public String generateProxy(String proxyName, String cacheDigest, ClassDescriptor classToProxy, HashSet methodOverrides, HashSet implementedInterfaces, boolean isInterface, AnnotationDescriptor[] annotations, List defaultMethods, + DefaultMethodBodies bodies) throws IOException { + boolean overridesDefaults = isInterface && defaultMethods != null && !proxyName.contains("."); + ApplicationWriter aw = new ApplicationWriter(overridesDefaults ? bodies.dexVersion : ApplicationWriter.DEFAULT_DEX_VERSION); aw.visit(); - dump.generateProxy(aw, proxyName, classToProxy, methodOverrides, implementedInterfaces, annotations, defaultMethods); + dump.generateProxy(aw, proxyName, classToProxy, methodOverrides, implementedInterfaces, annotations, defaultMethods, bodies); + if (overridesDefaults && bodies == DefaultMethodBodies.INVOKE_SUPER) { + DefaultSuperProbe.generate(aw, DefaultSuperProbe.descriptor(Dump.defaultOverridingDescriptor(classToProxy, bodies))); + } aw.visitEnd(); byte[] generatedBytes = aw.toByteArray(); @@ -68,7 +81,7 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto if (!isInterface) { proxyFileName += Dump.CLASS_NAME_LOCATION_SEPARATOR + proxyName; } else if (defaultMethods != null) { - proxyFileName += defaultOverridingFileSuffix(defaultMethods); + proxyFileName += defaultOverridingFileSuffix(defaultMethods, bodies); } if (proxyThumb != null) { proxyFileName += "-" + proxyThumb; @@ -93,8 +106,8 @@ public String generateProxy(String proxyName, String cacheDigest, ClassDescripto * names, so a dex cached for another list (a platform update that adds a default method * or an overload of one) must not be loaded: the methods' hash keeps it from matching. */ - public static String defaultOverridingFileSuffix(List defaultMethods) { - return Dump.DEFAULT_OVERRIDING_SUFFIX + "-" + DefaultMethods.signaturesHash(defaultMethods); + public static String defaultOverridingFileSuffix(List defaultMethods, DefaultMethodBodies bodies) { + return bodies.classSuffix + "-" + DefaultMethods.signaturesHash(defaultMethods); } private String saveProxy(String proxyName, byte[] proxyBytes) throws IOException { diff --git a/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java b/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java new file mode 100644 index 000000000..738c09bca --- /dev/null +++ b/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java @@ -0,0 +1,63 @@ +package com.tns; + +import android.util.Log; + +import com.tns.bindings.DefaultMethodBodies; +import com.tns.bindings.DefaultSuperProbe; + +import java.util.Arrays; + +/** + * How default-overriding classes run the defaults their JS object does not implement, decided + * once per process by the DefaultSuperProbe in the dex file of the first INVOKE_SUPER class + * loaded. When it fails, that and every later default-overriding class uses RUNTIME_CALL + * stubs, whose class names differ, since the class that failed keeps its name in its loader. + */ +final class DefaultSuperCalls { + private static final int UNDECIDED = 0; + private static final int PASSED = 1; + private static final int FAILED = 2; + + private static final Object decisionLock = new Object(); + private static volatile int decision = UNDECIDED; + + private DefaultSuperCalls() { + } + + static DefaultMethodBodies bodies(Class iface) { + return decision == FAILED ? DefaultMethodBodies.RUNTIME_CALL : DefaultMethodBodies.INVOKE_SUPER; + } + + /** + * Whether an INVOKE_SUPER class may be used: the first such class of the process runs its + * dex file's probe, which decides for every class. + */ + static boolean verify(Class defaultOverridingClass) { + int current = decision; + if (current != UNDECIDED) { + return current == PASSED; + } + synchronized (decisionLock) { + if (decision == UNDECIDED) { + String outcome; + int result; + try { + Class probe = Class.forName(DefaultSuperProbe.className(defaultOverridingClass.getName()), true, defaultOverridingClass.getClassLoader()); + DefaultSuperProbe.Call[] calls = DefaultSuperProbe.check(probe); + result = DefaultSuperProbe.passed(calls) ? PASSED : FAILED; + outcome = Arrays.toString(calls); + } catch (Throwable e) { + result = FAILED; + outcome = e.toString(); + } + decision = result; + if (result == PASSED) { + Log.d("JS", "Default methods a JS object lacks run with invoke-super: " + outcome); + } else { + Log.w("JS", "Default methods a JS object lacks run through the runtime: the invoke-super probe failed: " + outcome); + } + } + return decision == PASSED; + } + } +} 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 561085ff8..fc662c984 100644 --- a/test-app/runtime/src/main/java/com/tns/DexFactory.java +++ b/test-app/runtime/src/main/java/com/tns/DexFactory.java @@ -4,6 +4,7 @@ import android.util.Log; import com.tns.bindings.AnnotationDescriptor; +import com.tns.bindings.DefaultMethodBodies; import com.tns.bindings.DefaultMethods; import com.tns.bindings.Dump; import com.tns.bindings.ProxyGenerator; @@ -93,6 +94,7 @@ public Class resolveClass(String baseClassName, String name, String className // Only native asks for it, without a base class name; an extend() name the script // chose always comes with the base class's. boolean overridesDefaults = isInterface && baseClassName.isEmpty() && className.startsWith(COM_TNS_GEN_PREFIX) && className.endsWith(Dump.DEFAULT_OVERRIDING_SUFFIX); + String requestedClassName = className; if (overridesDefaults) { className = className.substring(0, className.length() - Dump.DEFAULT_OVERRIDING_SUFFIX.length()); } @@ -118,18 +120,24 @@ public Class resolveClass(String baseClassName, String name, String className } if (overridesDefaults) { - fullClassName += Dump.DEFAULT_OVERRIDING_SUFFIX; - originalFullClassName = fullClassName; + // Cached under the name native asks for, whichever class answers it. + originalFullClassName = fullClassName + Dump.DEFAULT_OVERRIDING_SUFFIX; } // new: com.tns.gen.android.widget.DatePicker_MyActivity_59_56_ // old: com.tns.tests.Button1_fMyActivity_l56_c44__MyButton // ne1: com.tns.tests.Button1_MyActivity_58_44_MyButton_0 - Class existingClass = this.injectedDexClasses.get(fullClassName); + Class existingClass = this.injectedDexClasses.get(originalFullClassName); if (existingClass != null) { return existingClass; } + DefaultMethodBodies bodies = null; + if (overridesDefaults) { + bodies = DefaultSuperCalls.bodies(Class.forName(this.getClassToProxyName(className))); + fullClassName += bodies.classSuffix; + } + String classToProxy; if (!baseClassName.isEmpty()) { classToProxy = this.getClassToProxyName(baseClassName); @@ -142,7 +150,7 @@ public Class resolveClass(String baseClassName, String name, String className if (overridesDefaults) { // The same file name ProxyGenerator writes the class under. desiredDexClassName = this.getClassToProxyName(className.replace("$", "_")) - + ProxyGenerator.defaultOverridingFileSuffix(DefaultMethods.collect(Class.forName(classToProxy))); + + ProxyGenerator.defaultOverridingFileSuffix(DefaultMethods.collect(Class.forName(classToProxy)), bodies); } // A named proxy (`Base.extend('a.b.C', {...})` / @JavaProxy) asks for @@ -173,9 +181,9 @@ public Class resolveClass(String baseClassName, String name, String className String dexFilePath; if (isInterface && !isNamedProxy) { - dexFilePath = this.generateDex(name, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, overridesDefaults); + dexFilePath = this.generateDex(name, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, bodies); } else { - dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, false); + dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, null); } dexFile = new File(dexFilePath); long stopGenTime = System.nanoTime(); @@ -229,6 +237,10 @@ public Class resolveClass(String baseClassName, String name, String className result = dexClassLoader.loadClass(classNameToLoad); } + if (bodies == DefaultMethodBodies.INVOKE_SUPER && !DefaultSuperCalls.verify(result)) { + return resolveClass(baseClassName, name, requestedClassName, methodOverrides, implementedInterfaces, isInterface); + } + generatedClassNames.add(result.getName()); classStorageService.storeClass(result.getName(), result); this.injectedDexClasses.put(originalFullClassName, result); @@ -377,7 +389,11 @@ private File getDexFile(String className, String contentDigest) throws InvalidCl return null; } - private String generateDex(String proxyName, String contentDigest, String className, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface, boolean overridesDefaults) throws ClassNotFoundException, IOException { + // defaultBodies: those of the default-overriding class of the interface className; null for + // any other class. + private String generateDex(String proxyName, String contentDigest, String className, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface, + DefaultMethodBodies defaultBodies) throws ClassNotFoundException, IOException { + boolean overridesDefaults = defaultBodies != null; Class classToProxy = Class.forName(className); HashSet methodOverridesSet = null; @@ -420,7 +436,8 @@ private String generateDex(String proxyName, String contentDigest, String classN } } } - return proxyGenerator.generateProxy(proxyName, contentDigest, new ClassInfo(classToProxy), methodOverridesSet, implementedInterfacesSet, isInterface, annotations, defaultMethods); + return proxyGenerator.generateProxy(proxyName, contentDigest, new ClassInfo(classToProxy), methodOverridesSet, implementedInterfacesSet, isInterface, annotations, defaultMethods, + overridesDefaults ? defaultBodies : DefaultMethodBodies.INVOKE_SUPER); } private void updateDexThumbAndPurgeCache() { 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 ba79fa3ee..20928ffbf 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 @@ -172,7 +172,8 @@ public void keyNamesTheDeclaringInterfaceAndTheSignature() throws Exception { } private static byte[] generate(Class iface, boolean overrideDefaults) { - org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter(); + org.ow2.asmdex.ApplicationWriter aw = new org.ow2.asmdex.ApplicationWriter( + overrideDefaults ? DefaultMethodBodies.INVOKE_SUPER.dexVersion : org.ow2.asmdex.ApplicationWriter.DEFAULT_DEX_VERSION); aw.visit(); ClassDescriptor descriptor = new ClassInfo(iface); new Dump().generateProxy(aw, "", descriptor, null, new HashSet(), null, @@ -297,14 +298,14 @@ public void theDefaultOverridingFileNameChangesWithTheDefaultMethodNames() throw List withAnother = new ArrayList<>(iteratorDefaults); withAnother.add(Derived.class.getMethod("redefined")); - String suffix = ProxyGenerator.defaultOverridingFileSuffix(iteratorDefaults); + String suffix = ProxyGenerator.defaultOverridingFileSuffix(iteratorDefaults, DefaultMethodBodies.INVOKE_SUPER); assertTrue(suffix.startsWith(Dump.DEFAULT_OVERRIDING_SUFFIX + "-")); - assertEquals(suffix, ProxyGenerator.defaultOverridingFileSuffix(new ArrayList<>(iteratorDefaults))); - assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withoutRemove))); - assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withAnother))); + assertEquals(suffix, ProxyGenerator.defaultOverridingFileSuffix(new ArrayList<>(iteratorDefaults), DefaultMethodBodies.INVOKE_SUPER)); + assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withoutRemove, DefaultMethodBodies.INVOKE_SUPER))); + assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withAnother, DefaultMethodBodies.INVOKE_SUPER))); List withOverload = new ArrayList<>(iteratorDefaults); withOverload.add(java.util.PrimitiveIterator.OfInt.class.getMethod("forEachRemaining", java.util.function.IntConsumer.class)); - assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withOverload))); + assertFalse(suffix.equals(ProxyGenerator.defaultOverridingFileSuffix(withOverload, DefaultMethodBodies.INVOKE_SUPER))); java.io.File dir = java.nio.file.Files.createTempDirectory("proxies").toFile(); try { diff --git a/test-app/runtime/src/test/java/com/tns/bindings/DefaultSuperBodiesTest.java b/test-app/runtime/src/test/java/com/tns/bindings/DefaultSuperBodiesTest.java new file mode 100644 index 000000000..a3383da51 --- /dev/null +++ b/test-app/runtime/src/test/java/com/tns/bindings/DefaultSuperBodiesTest.java @@ -0,0 +1,191 @@ +package com.tns.bindings; + +import com.tns.bindings.desc.ClassDescriptor; +import com.tns.bindings.desc.reflection.ClassInfo; + +import org.junit.Test; +import org.ow2.asmdex.ApplicationReader; +import org.ow2.asmdex.ApplicationVisitor; +import org.ow2.asmdex.ClassVisitor; +import org.ow2.asmdex.MethodVisitor; +import org.ow2.asmdex.Opcodes; + +import java.io.File; +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +public class DefaultSuperBodiesTest { + + public interface WideBase { + default long wide(long a, double b, int c) { + return a + (long) b + c; + } + } + + public interface Wide extends WideBase { + void abstractOne(); + + default Object same(Object value) { + return value; + } + + default char letter() { + return 'x'; + } + + default void nothing() { + } + } + + private static final String WIDE = "Lcom/tns/bindings/DefaultSuperBodiesTest$Wide;"; + private static final String OVERRIDING = "Lcom/tns/gen/com/tns/bindings/DefaultSuperBodiesTest_Wide-defaults;"; + private static final String RUNTIME_CALLING = "Lcom/tns/gen/com/tns/bindings/DefaultSuperBodiesTest_Wide-defaults-jni;"; + + private static final class Call { + final int opcode; + final String owner; + final String name; + final String desc; + final int[] arguments; + + Call(int opcode, String owner, String name, String desc, int[] arguments) { + this.opcode = opcode; + this.owner = owner; + this.name = name; + this.desc = desc; + this.arguments = arguments; + } + } + + private static final class Dex { + String version; + final Map interfaces = new HashMap<>(); + // "Class.methodDesc" -> its method calls + final Map> calls = new HashMap<>(); + } + + private static Dex read(byte[] bytes) { + final Dex dex = new Dex(); + dex.version = new String(bytes, 4, 3, java.nio.charset.StandardCharsets.US_ASCII); + new ApplicationReader(Opcodes.ASM4, bytes).accept(new ApplicationVisitor(Opcodes.ASM4) { + @Override + public ClassVisitor visitClass(int access, final String className, String[] signature, String superName, String[] interfaces) { + dex.interfaces.put(className, interfaces); + return new ClassVisitor(Opcodes.ASM4) { + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String[] signature, String[] exceptions) { + final List calls = new ArrayList<>(); + dex.calls.put(className + "." + name + desc, calls); + return new MethodVisitor(Opcodes.ASM4) { + @Override + public void visitMethodInsn(int opcode, String owner, String name, String desc, int[] arguments) { + calls.add(new Call(opcode, owner, name, desc, arguments)); + } + }; + } + }; + } + }, 0); + return dex; + } + + private static byte[] generate(DefaultMethodBodies bodies, String[] fileName) throws Exception { + File dir = Files.createTempDirectory("proxies").toFile(); + try { + String path = new ProxyGenerator(dir.getAbsolutePath()).generateProxy("", null, new ClassInfo(Wide.class), null, + new HashSet(), true, null, DefaultMethods.collect(Wide.class), bodies); + fileName[0] = new File(path).getName(); + return Files.readAllBytes(new File(path).toPath()); + } finally { + for (File file : dir.listFiles()) { + file.delete(); + } + dir.delete(); + } + } + + private static Call superCall(Dex dex, String method) { + Call found = null; + for (Call call : dex.calls.get(OVERRIDING + "." + method)) { + assertFalse(call.name.equals(Dump.callInterfaceDefaultMethodName)); + if (call.opcode == Opcodes.INSN_INVOKE_SUPER_RANGE) { + found = call; + } + } + assertNotNull(method, found); + return found; + } + + @Test + public void invokeSuperStubsNameTheImplementedInterfaceAndPassTheirOwnRegisters() throws Exception { + String[] fileName = new String[1]; + Dex dex = read(generate(DefaultMethodBodies.INVOKE_SUPER, fileName)); + + assertEquals("037", dex.version); + + // v0-v2 are locals, v3 is this + Call wide = superCall(dex, "wideJJDI"); + assertEquals(WIDE, wide.owner); + assertEquals("wide", wide.name); + assertEquals("JJDI", wide.desc); + assertArrayEquals(new int[] { 3, 4, 5, 6, 7, 8 }, wide.arguments); + + assertArrayEquals(new int[] { 3, 4 }, superCall(dex, "sameLjava/lang/Object;Ljava/lang/Object;").arguments); + assertArrayEquals(new int[] { 3 }, superCall(dex, "letterC").arguments); + assertEquals(WIDE, superCall(dex, "nothingV").owner); + + assertEquals(new HashSet<>(Arrays.asList(OVERRIDING, DefaultSuperProbe.descriptor(OVERRIDING))), dex.interfaces.keySet()); + assertTrue(Arrays.asList(dex.interfaces.get(DefaultSuperProbe.descriptor(OVERRIDING))) + .containsAll(Arrays.asList("Ljava/util/PrimitiveIterator$OfInt;", "Ljava/util/Comparator;"))); + assertEquals(DefaultSuperBodiesTest.class.getName() + "_Wide" + Dump.DEFAULT_OVERRIDING_SUFFIX + "-" + + DefaultMethods.signaturesHash(DefaultMethods.collect(Wide.class)) + ".dex", fileName[0]); + } + + @Test + public void runtimeCallStubsHaveTheirOwnNameAndADex035FileWithoutAProbe() throws Exception { + String[] fileName = new String[1]; + Dex dex = read(generate(DefaultMethodBodies.RUNTIME_CALL, fileName)); + + assertEquals("035", dex.version); + assertEquals(new HashSet<>(Arrays.asList(RUNTIME_CALLING)), dex.interfaces.keySet()); + boolean callsRuntime = false; + for (Call call : dex.calls.get(RUNTIME_CALLING + ".wideJJDI")) { + assertFalse(call.opcode == Opcodes.INSN_INVOKE_SUPER_RANGE); + callsRuntime |= call.name.equals(Dump.callInterfaceDefaultMethodName); + } + assertTrue(callsRuntime); + assertEquals(DefaultSuperBodiesTest.class.getName() + "_Wide" + Dump.DEFAULT_OVERRIDING_SUFFIX + "-jni-" + + DefaultMethods.signaturesHash(DefaultMethods.collect(Wide.class)) + ".dex", fileName[0]); + } + + @Test + public void theTwoKindsNeverShareADexFile() { + List defaults = DefaultMethods.collect(Wide.class); + assertFalse(ProxyGenerator.defaultOverridingFileSuffix(defaults, DefaultMethodBodies.RUNTIME_CALL) + .equals(ProxyGenerator.defaultOverridingFileSuffix(defaults, DefaultMethodBodies.INVOKE_SUPER))); + } + + @Test + public void theWriterKeepsItsVersionToItself() { + org.ow2.asmdex.ApplicationWriter v37 = new org.ow2.asmdex.ApplicationWriter(37); + org.ow2.asmdex.ApplicationWriter v35 = new org.ow2.asmdex.ApplicationWriter(); + v37.visit(); + v37.visitEnd(); + v35.visit(); + v35.visitEnd(); + assertEquals("037", new String(v37.toByteArray(), 4, 3, java.nio.charset.StandardCharsets.US_ASCII)); + assertEquals("035", new String(v35.toByteArray(), 4, 3, java.nio.charset.StandardCharsets.US_ASCII)); + } +} From de85ebab524de570d30b008b7d1357b0da0033bf Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 14:09:26 -0300 Subject: [PATCH 14/16] test: run the runtime-call stubs of default methods in the default suite The stubs that run a default's Java body through the runtime are the fallback when a process's invoke-super probe fails, so a passing probe never uses them. A package-private DefaultSuperCalls.useRuntimeCallsFor, which a test fixture reaches by reflection, gives one interface those stubs. Specs use it for interfaces no other spec touches: a default run on the calling thread, one implemented in JS, a wide argument passed back to JS, wide, generic and bridged signatures, and a default of a non-public super-interface. --- .../testInterfaceDefaultMethodOverrides.js | 105 +++++++++++++++++- .../com/tns/tests/DefaultMethodFixtures.java | 39 +++++++ .../tns/tests/TemporalDefaultFixtures.java | 12 ++ .../RuntimeCallCaller.java | 51 +++++++++ .../RuntimeCallHidden.java | 8 ++ .../RuntimeCallShapes.java | 22 ++++ .../RuntimeCallStringShapes.java | 9 ++ .../RuntimeCallVisible.java | 9 ++ .../main/java/com/tns/DefaultSuperCalls.java | 19 +++- 9 files changed, 272 insertions(+), 2 deletions(-) create mode 100644 test-app/app/src/main/java/com/tns/tests/TemporalDefaultFixtures.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallCaller.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallHidden.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallShapes.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallStringShapes.java create mode 100644 test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallVisible.java diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index cbe6e2d4f..b995558c9 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -618,7 +618,7 @@ describe("Interface default methods implemented in JS", function () { expect(odd).toEqual([3]); expect(D.ShapesCaller.fail(shapes)).toBe("com.tns.tests.interfaces.defaultshapes.ShapesException: from java"); - // same(Object), the bridge, reaches the narrowed default through the stub. + // A call of the erased same(Object) runs javac's bridge, which reaches the narrowed default. var strings = new D.StringShapes({ name: function () { return "s"; }, odd: function () { return true; } @@ -626,3 +626,106 @@ describe("Interface default methods implemented in JS", function () { expect(D.ShapesCaller.all(strings)).toBe("7028|2.5|0.5|Q|true|-4|42|s:9223372036854775807:-0.25|string v"); }); }); + +// The class a process uses for every interface when its invoke-super probe fails, requested +// here for interfaces no other spec uses, before their classes are first resolved. +describe("Interface default methods run through the runtime", function () { + var sdk = android.os.Build.VERSION.SDK_INT; + var F = com.tns.tests.DefaultMethodFixtures; + var SUFFIX = "-defaults-jni"; + var DoubleOp = java.util.function.DoubleUnaryOperator; + + it("run a default the JS object lacks on the calling thread, and one it implements in JS", function () { + if (sdk < 24) { + return; + } + F.useRuntimeCallStubs(DoubleOp.class); + var composed = []; + var op = new DoubleOp({ + applyAsDouble: function (value) { return value * 3; }, + compose: function (before) { + composed.push(before !== null); + return null; + } + }); + + expect(F.className(op)).toBe("com.tns.gen.java.util.function.DoubleUnaryOperator" + SUFFIX); + // This thread waits inside the fixture, so a call that needed it would time out. + expect(F.doubleAndThenOnBackgroundThread(op, 5000)).toBe(F.CALLER_THREAD + "|true"); + expect(F.doubleAndThenApply(op, 2)).toBe("6.0"); + expect(F.doubleCompose(op)).toBe("null"); + expect(composed).toEqual([true]); + }, 15000); + + it("pass a wide argument from a default's Java body back to JS", function () { + if (sdk < 26) { + return; + } + var TemporalType = java.time.temporal.Temporal; + F.useRuntimeCallStubs(TemporalType.class); + var added = []; + var temporal = new TemporalType({ + plus: function (amount, unit) { + added.push(amount + " " + unit); + return this; + } + }); + + expect(F.className(temporal)).toBe("com.tns.gen.java.time.temporal.Temporal" + SUFFIX); + expect(com.tns.tests.TemporalDefaultFixtures.minusDays(temporal, 5)).toBe(true); + expect(added).toEqual(["-5 Days"]); + }); + + it("run defaults of wide, generic and bridged signatures through the runtime", function () { + if (sdk < 24) { + return; + } + var R = com.tns.tests.interfaces.runtimecalldefaults; + if (R.RuntimeCallCaller.isDesugared()) { + // Below minSdk 24 every method is abstract on the device. + return; + } + F.useRuntimeCallStubs(R.RuntimeCallShapes.class); + F.useRuntimeCallStubs(R.RuntimeCallStringShapes.class); + var odd = []; + var shapes = new R.RuntimeCallShapes({ + name: function () { return "js"; }, + odd: function (value) { + odd.push(value); + return false; + } + }); + + expect(F.className(shapes)).toBe("com.tns.gen.com.tns.tests.interfaces.runtimecalldefaults.RuntimeCallShapes" + SUFFIX); + expect(R.RuntimeCallCaller.all(shapes)).toBe("7028|2.5|false|v"); + expect(odd).toEqual([3]); + expect(R.RuntimeCallCaller.wideOnBackgroundThread(shapes, 5000)).toBe(F.CALLER_THREAD + "|9223372036854774996"); + + // A call of the erased same(Object) runs javac's bridge, which reaches the narrowed default. + var strings = new R.RuntimeCallStringShapes({ + name: function () { return "s"; }, + odd: function () { return true; } + }); + expect(F.className(strings)).toBe("com.tns.gen.com.tns.tests.interfaces.runtimecalldefaults.RuntimeCallStringShapes" + SUFFIX); + expect(R.RuntimeCallCaller.all(strings)).toBe("7028|2.5|true|string v"); + }, 15000); + + it("run a default declared in a non-public super-interface through the runtime", function () { + if (sdk < 24) { + return; + } + var R = com.tns.tests.interfaces.runtimecalldefaults; + if (R.RuntimeCallCaller.isDesugared()) { + return; + } + F.useRuntimeCallStubs(R.RuntimeCallVisible.class); + var visibleOnly = new R.RuntimeCallVisible({ + name: function () { return "js"; }, + visible: function () { return "visible js"; } + }); + + expect(F.className(visibleOnly)).toBe("com.tns.gen.com.tns.tests.interfaces.runtimecalldefaults.RuntimeCallVisible" + SUFFIX); + expect(R.RuntimeCallCaller.visible(visibleOnly)).toBe("visible js"); + expect(R.RuntimeCallCaller.hidden(visibleOnly)).toBe("hidden java"); + }); +}); diff --git a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java index dd0b12536..15e5aaaa3 100644 --- a/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -12,6 +12,7 @@ import java.util.function.BiPredicate; import java.util.function.Consumer; import java.util.function.DoublePredicate; +import java.util.function.DoubleUnaryOperator; import java.util.function.IntConsumer; import java.util.function.IntPredicate; import java.util.function.LongPredicate; @@ -190,6 +191,44 @@ public void run() { return caller.isAlive() ? "timeout" : result[0]; } + /* + * Makes the runtime give iface's default-overriding class the stubs that run Java bodies + * through the runtime, which it otherwise uses only when its invoke-super probe fails. The + * runtime keeps this test switch package-private, so it is reached by reflection; it must + * come before the class is first resolved. + */ + public static void useRuntimeCallStubs(Class iface) throws ReflectiveOperationException { + java.lang.reflect.Method use = Class.forName("com.tns.DefaultSuperCalls").getDeclaredMethod("useRuntimeCallsFor", Class.class); + use.setAccessible(true); + use.invoke(null, iface); + } + + // Calls op.andThen() on a new thread while the calling (JS) thread waits here. + public static String doubleAndThenOnBackgroundThread(final DoubleUnaryOperator op, long timeoutMillis) throws InterruptedException { + final String[] result = new String[1]; + Thread caller = new Thread(new Runnable() { + @Override + public void run() { + try { + result[0] = Thread.currentThread().getName() + "|" + (op.andThen(DoubleUnaryOperator.identity()) != null); + } catch (Throwable t) { + result[0] = t.getClass().getName(); + } + } + }, CALLER_THREAD); + caller.start(); + caller.join(timeoutMillis); + return caller.isAlive() ? "timeout" : result[0]; + } + + public static String doubleAndThenApply(DoubleUnaryOperator op, double value) { + return Double.toString(op.andThen(DoubleUnaryOperator.identity()).applyAsDouble(value)); + } + + public static String doubleCompose(DoubleUnaryOperator op) { + return java.util.Objects.toString(op.compose(DoubleUnaryOperator.identity())); + } + public static String describeOnBackgroundThread(final AllDefaultListener listener, long timeoutMillis) throws InterruptedException { final String[] result = new String[1]; Thread caller = new Thread(new Runnable() { diff --git a/test-app/app/src/main/java/com/tns/tests/TemporalDefaultFixtures.java b/test-app/app/src/main/java/com/tns/tests/TemporalDefaultFixtures.java new file mode 100644 index 000000000..4f84f3666 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/TemporalDefaultFixtures.java @@ -0,0 +1,12 @@ +package com.tns.tests; + +import java.time.temporal.ChronoUnit; +import java.time.temporal.Temporal; + +// java.time is API 26; specs touch this only on API 26+. +public class TemporalDefaultFixtures { + // Temporal.minus(long, TemporalUnit) is a default that calls plus(-amount, unit). + public static boolean minusDays(Temporal temporal, long amount) { + return temporal.minus(amount, ChronoUnit.DAYS) == temporal; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallCaller.java b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallCaller.java new file mode 100644 index 000000000..d29eba35a --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallCaller.java @@ -0,0 +1,51 @@ +package com.tns.tests.interfaces.runtimecalldefaults; + +import com.tns.tests.DefaultMethodFixtures; + +// Java callers for the runtime-call specs of testInterfaceDefaultMethodOverrides.js. +public class RuntimeCallCaller { + public static String all(RuntimeCallShapes shapes) { + return shapes.wide(7, 2.5, 3) + "|" + shapes.half(5) + "|" + shapes.odd(3) + "|" + shapes.same("v"); + } + + public static String hidden(RuntimeCallVisible instance) { + try { + return instance.hidden(); + } catch (Throwable t) { + return t.getClass().getName() + ": " + t.getMessage(); + } + } + + public static String visible(RuntimeCallVisible instance) { + try { + return instance.visible(); + } catch (Throwable t) { + return t.getClass().getName() + ": " + t.getMessage(); + } + } + + /* + * Calls shapes.wide() on a new thread while the calling (JS) thread waits here, so a call + * that needed the JS thread could not complete before the timeout. + */ + public static String wideOnBackgroundThread(final RuntimeCallShapes shapes, long timeoutMillis) throws InterruptedException { + final String[] result = new String[1]; + Thread caller = new Thread(new Runnable() { + @Override + public void run() { + try { + result[0] = Thread.currentThread().getName() + "|" + shapes.wide(Long.MAX_VALUE / 1000, -0.5, 1); + } catch (Throwable t) { + result[0] = t.getClass().getName(); + } + } + }, DefaultMethodFixtures.CALLER_THREAD); + caller.start(); + caller.join(timeoutMillis); + return caller.isAlive() ? "timeout" : result[0]; + } + + public static boolean isDesugared() throws NoSuchMethodException { + return !RuntimeCallShapes.class.getMethod("half", long.class).isDefault(); + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallHidden.java b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallHidden.java new file mode 100644 index 000000000..f4efde7ac --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallHidden.java @@ -0,0 +1,8 @@ +package com.tns.tests.interfaces.runtimecalldefaults; + +// Package-private: a class generated in another package cannot name it. +interface RuntimeCallHidden { + default String hidden() { + return "hidden java"; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallShapes.java b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallShapes.java new file mode 100644 index 000000000..7f8cf7499 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallShapes.java @@ -0,0 +1,22 @@ +package com.tns.tests.interfaces.runtimecalldefaults; + +// For the runtime-call stubs only: no spec lets this interface get the invoke-super class. +public interface RuntimeCallShapes { + String name(); + + default long wide(long a, double b, int c) { + return a * 1000 + (long) (b * 10) + c; + } + + default double half(long value) { + return value / 2.0; + } + + default boolean odd(int value) { + return (value & 1) != 0; + } + + default T same(T value) { + return value; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallStringShapes.java b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallStringShapes.java new file mode 100644 index 000000000..b9d3f79dc --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallStringShapes.java @@ -0,0 +1,9 @@ +package com.tns.tests.interfaces.runtimecalldefaults; + +// Narrows the generic default; javac adds the bridge same(Object) that forwards to it. +public interface RuntimeCallStringShapes extends RuntimeCallShapes { + @Override + default String same(String value) { + return "string " + value; + } +} diff --git a/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallVisible.java b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallVisible.java new file mode 100644 index 000000000..9d5bbb7c3 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/interfaces/runtimecalldefaults/RuntimeCallVisible.java @@ -0,0 +1,9 @@ +package com.tns.tests.interfaces.runtimecalldefaults; + +public interface RuntimeCallVisible extends RuntimeCallHidden { + String name(); + + default String visible() { + return "visible java"; + } +} diff --git a/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java b/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java index 738c09bca..9d4e41283 100644 --- a/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java +++ b/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java @@ -6,6 +6,9 @@ import com.tns.bindings.DefaultSuperProbe; import java.util.Arrays; +import java.util.Collections; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; /** * How default-overriding classes run the defaults their JS object does not implement, decided @@ -21,11 +24,16 @@ final class DefaultSuperCalls { private static final Object decisionLock = new Object(); private static volatile int decision = UNDECIDED; + private static final Set> runtimeCallInterfaces = Collections.newSetFromMap(new ConcurrentHashMap, Boolean>()); + private DefaultSuperCalls() { } static DefaultMethodBodies bodies(Class iface) { - return decision == FAILED ? DefaultMethodBodies.RUNTIME_CALL : DefaultMethodBodies.INVOKE_SUPER; + if (decision == FAILED || (!runtimeCallInterfaces.isEmpty() && runtimeCallInterfaces.contains(iface))) { + return DefaultMethodBodies.RUNTIME_CALL; + } + return DefaultMethodBodies.INVOKE_SUPER; } /** @@ -60,4 +68,13 @@ static boolean verify(Class defaultOverridingClass) { return decision == PASSED; } } + + /* + * Makes the iface's default-overriding class use RUNTIME_CALL stubs whatever the probe + * decides. For tests of those stubs only, which reach it by reflection; it must come before + * the class is first resolved. + */ + static void useRuntimeCallsFor(Class iface) { + runtimeCallInterfaces.add(iface); + } } From f06ab2c44882d75aaee3a794a34a898d902719e7 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 14:10:05 -0300 Subject: [PATCH 15/16] test: check that no default-overriding class of either kind loads needlessly --- .../assets/app/tests/testInterfaceDefaultMethodOverrides.js | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js index b995558c9..9676fb2bb 100644 --- a/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -4,7 +4,11 @@ describe("Interface default methods implemented in JS", function () { var sdk = android.os.Build.VERSION.SDK_INT; var F = com.tns.tests.DefaultMethodFixtures; + // Names the class whose stubs run Java bodies with invoke-super, which every class + // asserted with it must be: a process whose probe failed names its classes + // RUNTIME_CALL_SUFFIX instead. var SUFFIX = "-defaults"; + var RUNTIME_CALL_SUFFIX = "-defaults-jni"; var It = java.util.Iterator; var Pred = java.util.function.Predicate; @@ -149,6 +153,7 @@ describe("Interface default methods implemented in JS", function () { expect(F.className(predicate)).toBe("com.tns.gen.java.util.function.IntPredicate"); expect(F.isClassLoaded("com.tns.gen.java.util.function.IntPredicate" + SUFFIX, predicate)).toBe(false); + expect(F.isClassLoaded("com.tns.gen.java.util.function.IntPredicate" + RUNTIME_CALL_SUFFIX, predicate)).toBe(false); expect(F.intNegate(predicate, 1)).toBe("true|false"); var plain = new Pred({ test: function () { return true; } }); From 4834365d6d43051a7a6e7531f8a7812629387041 Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Tue, 17 Nov 2026 14:10:27 -0300 Subject: [PATCH 16/16] docs(runtime): name the stubs that call callInterfaceDefault --- test-app/runtime/src/main/java/com/tns/Runtime.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test-app/runtime/src/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java index d1d51610f..c7a2f5f9a 100644 --- a/test-app/runtime/src/main/java/com/tns/Runtime.java +++ b/test-app/runtime/src/main/java/com/tns/Runtime.java @@ -1004,10 +1004,10 @@ private static String[] getDefaultMethodNames(String interfaceName) { private static final ConcurrentHashMap interfaceDefaultMethods = new ConcurrentHashMap(); /* - * Called by a generated class's stub of a default method the instance's JS object does - * not implement: runs the interface's body on the calling thread. key is - * DefaultMethods.key of the method, declared by implementedInterface or one of its - * super-interfaces. + * Called by a RUNTIME_CALL (com.tns.bindings.DefaultMethodBodies) stub of a default method + * the instance's JS object does not implement: runs the interface's body on the calling + * thread. key is DefaultMethods.key of the method, declared by implementedInterface or + * one of its super-interfaces. */ public static Object callInterfaceDefault(Object receiver, Class implementedInterface, String key, Object[] args) { Method method = interfaceDefaultMethods.get(key);