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/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..9676fb2bb --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethodOverrides.js @@ -0,0 +1,736 @@ +// 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; + // 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; + 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.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; } }); + 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("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); + }); + + 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("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("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("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; + } + 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; + } + 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); + + 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"); + + // 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; } + }); + 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 new file mode 100644 index 000000000..15e5aaaa3 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/DefaultMethodFixtures.java @@ -0,0 +1,248 @@ +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; +import java.util.Spliterator; +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; +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 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()); + } catch (Throwable t) { + return t.getClass().getName(); + } + } + + 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 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(); + } + + /* + * 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]; + } + + /* + * 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() { + @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/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/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/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/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/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-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/DefaultMethods.java b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java new file mode 100644 index 000000000..5c35aaef6 --- /dev/null +++ b/test-app/runtime-binding-generator/src/main/java/com/tns/bindings/DefaultMethods.java @@ -0,0 +1,210 @@ +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()); + } + + /** + * 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()); + } + + 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()) { + 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)) { + continue; + } + if (method.isBridge()) { + bridges.add(method); + continue; + } + if (method.isSynthetic()) { + 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() && !isBridged(mostSpecific, bridges)) { + 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; + } + + /* + * 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<>(); + for (Method method : collect(iface)) { + names.add(method.getName()); + } + return names.toArray(new String[0]); + } + + /** 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) { + keys.add(key(method)); + } + int hash = 0x811c9dc5; + for (String key : keys) { + for (int i = 0; i < key.length(); i++) { + hash ^= key.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<>(); + 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('('); + 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/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 79d959b23..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 @@ -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,7 +175,28 @@ 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 (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) { + 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("."); String tnsClassSignature; if (proxyName.contains(".")) { @@ -173,6 +207,8 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto if (!classTo.isInterface()) { tnsClassSignature += CLASS_NAME_LOCATION_SEPARATOR + proxyName; + } else if (overridesDefaults) { + tnsClassSignature += bodies.classSuffix; } tnsClassSignature += ";"; @@ -182,8 +218,15 @@ 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 (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(); + } MethodDescriptor[] ctors = classTo.getConstructors(); @@ -192,9 +235,125 @@ public void generateProxy(ApplicationWriter aw, String proxyName, ClassDescripto generateMethods(cv, classTo, methods, classSignature, tnsClassSignature); + if (overridesDefaults) { + 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(); + 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, DefaultMethodBodies bodies) { + 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, bodies); + } + } + + 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, 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, DefaultMethodBodies bodies) { + 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); + 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); + 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(); + } + + // 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 1cbfc8b0f..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 @@ -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,28 @@ 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 { - ApplicationWriter aw = new ApplicationWriter(); + 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 { + 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); + 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(); @@ -60,6 +80,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 += defaultOverridingFileSuffix(defaultMethods, bodies); } if (proxyThumb != null) { proxyFileName += "-" + proxyThumb; @@ -78,6 +100,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 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, DefaultMethodBodies bodies) { + return bodies.classSuffix + "-" + DefaultMethods.signaturesHash(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-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"); } diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp index 92dd9afb4..f76782bbe 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,75 @@ 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 + +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; + + 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()); @@ -155,8 +222,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(); @@ -182,6 +251,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 +2090,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..b1964b0be 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.h +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.h @@ -40,7 +40,14 @@ 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); + + // 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); static jclass ResolveClass(v8::Isolate *isolate, const std::string &baseClassName, const std::string &fullClassName, @@ -199,6 +206,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..a9a6912f5 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,23 @@ 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 && !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) + : 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 +2066,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 +2585,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/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/DefaultSuperCalls.java b/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java new file mode 100644 index 000000000..9d4e41283 --- /dev/null +++ b/test-app/runtime/src/main/java/com/tns/DefaultSuperCalls.java @@ -0,0 +1,80 @@ +package com.tns; + +import android.util.Log; + +import com.tns.bindings.DefaultMethodBodies; +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 + * 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 static final Set> runtimeCallInterfaces = Collections.newSetFromMap(new ConcurrentHashMap, Boolean>()); + + private DefaultSuperCalls() { + } + + static DefaultMethodBodies bodies(Class iface) { + if (decision == FAILED || (!runtimeCallInterfaces.isEmpty() && runtimeCallInterfaces.contains(iface))) { + return DefaultMethodBodies.RUNTIME_CALL; + } + return 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; + } + } + + /* + * 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); + } +} 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..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,9 @@ 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; import com.tns.bindings.desc.ClassDescriptor; import com.tns.bindings.desc.reflection.ClassInfo; @@ -23,9 +26,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 +52,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 +89,16 @@ 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. + // 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()); + } + String fullClassName = className.replace("$", "_"); String originalFullClassName = fullClassName; @@ -91,18 +111,33 @@ 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) { + // 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); @@ -112,6 +147,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)), bodies); + } // A named proxy (`Base.extend('a.b.C', {...})` / @JavaProxy) asks for // exactly that Java class name; the substitutions below are for the @@ -141,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); + dexFilePath = this.generateDex(name, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, bodies); } else { - dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface); + dexFilePath = this.generateDex(desiredDexClassName, contentDigest, classToProxy, methodOverrides, implementedInterfaces, isInterface, null); } dexFile = new File(dexFilePath); long stopGenTime = System.nanoTime(); @@ -197,6 +237,11 @@ 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); @@ -344,11 +389,16 @@ 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 { + // 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; HashSet implementedInterfacesSet = new HashSet(); + List> implementedInterfaceClasses = new ArrayList>(); if (methodOverrides != null) { methodOverridesSet = new HashSet(); @@ -362,13 +412,32 @@ 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; - return proxyGenerator.generateProxy(proxyName, contentDigest, new ClassInfo(classToProxy), methodOverridesSet, implementedInterfacesSet, isInterface, annotations); + List defaultMethods = null; + if (overridesDefaults) { + defaultMethods = DefaultMethods.collect(classToProxy); + } else if ((!classToProxy.isInterface() || proxyName.contains(".")) && Build.VERSION.SDK_INT >= 24) { + // A named interface implementation is one extend() call's class, so like a class + // it stubs only the default methods its implementation object names. + List inheritedDefaults = classToProxy.isInterface() + ? DefaultMethods.collect(classToProxy) + : DefaultMethods.collect(classToProxy, implementedInterfaceClasses); + defaultMethods = new ArrayList(); + for (Method inherited : inheritedDefaults) { + if (methodOverridesSet == null || methodOverridesSet.contains(inherited.getName())) { + defaultMethods.add(inherited); + } + } + } + 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/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java index 75ec2758c..c7a2f5f9a 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,50 @@ 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 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); + 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); + } + @RuntimeCallable private static String[] getTypeMetadata(String className, int index) throws ClassNotFoundException { Class clazz = classStorageService.retrieveClass(className); @@ -1658,6 +1703,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; 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..20928ffbf --- /dev/null +++ b/test-app/runtime/src/test/java/com/tns/bindings/DefaultMethodsTest.java @@ -0,0 +1,328 @@ +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()); + } + + 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() { + 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"))); + 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( + 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, + 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 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")); + } + + 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 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, DefaultMethodBodies.INVOKE_SUPER); + assertTrue(suffix.startsWith(Dump.DEFAULT_OVERRIDING_SUFFIX + "-")); + 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, DefaultMethodBodies.INVOKE_SUPER))); + + 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)); + assertArrayEquals(generate(Iterator.class, false), generate(Iterator.class, false)); + } +} 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)); + } +}