Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -80,4 +80,5 @@ require('./tests/testURLPattern.js');
require('./tests/testQueueMicrotask.js');
require('./tests/testConcurrentAccess.js');
require('./tests/testClassForNameDiscovery.js');
require('./tests/testPrebuiltExtendClasses');
require('./tests/testNativeTimers.js');
Original file line number Diff line number Diff line change
@@ -0,0 +1,5 @@
exports.DollarFileObject = java.lang.Object.extend({
toString: function () {
return "dollar file";
}
});
Original file line number Diff line number Diff line change
@@ -0,0 +1,79 @@
describe("Prebuilt classes of anonymous extends", function () {

var filesDir = __dirname.replace(/\/app\/tests$/, "");
var dataDir = filesDir.replace(/\/files$/, "");
var dexDirs = [dataDir + "/code_cache/secondary-dexes", filesDir + "/secondary-dexes"];

function generatedDexFiles(instance) {
var proxyName = instance.getClass().getName().replace(/^com\.tns\.gen\./, "");
var result = [];
dexDirs.forEach(function (dir) {
var files = new java.io.File(dir).list();
if (!files) {
return;
}
for (var i = 0; i < files.length; i++) {
var file = files[i];
if (file.indexOf(proxyName + "-") === 0 && /\.dex$/.test(file)) {
result.push(file);
}
}
});
return result;
}

it("loads an anonymous extend's class from the APK", function () {
var Anonymous = java.lang.Object.extend({
toString: function () {
return "anonymous";
}
});
var instance = new Anonymous();

expect(instance.toString()).toBe("anonymous");
expect(generatedDexFiles(instance)).toEqual([]);
});

it("loads a TypeScript-compiled native class from the APK", function () {
var CompiledClass = (function (_super) {
__extends(CompiledClass, _super);
function CompiledClass() {
var _this = _super.call(this) || this;
return global.__native(_this);
}
CompiledClass.prototype.toString = function () {
return "compiled";
};
return CompiledClass;
}(java.lang.Object));
var instance = new CompiledClass();

expect(instance.toString()).toBe("compiled");
expect(generatedDexFiles(instance)).toEqual([]);
});

it("loads a TypeScript-compiled native class without a constructor from the APK", function () {
var NoConstructorClass = (function (_super) {
__extends(NoConstructorClass, _super);
function NoConstructorClass() {
return _super !== null && _super.apply(this, arguments) || this;
}
NoConstructorClass.prototype.toString = function () {
return "no constructor";
};
return NoConstructorClass;
}(java.lang.Object));
var instance = new NoConstructorClass();

expect(instance.toString()).toBe("no constructor");
expect(generatedDexFiles(instance)).toEqual([]);
});

it("loads the class of an extend in a file with $ in its name from the APK", function () {
var DollarFileObject = require("./prebuiltExtend$Dollar").DollarFileObject;
var instance = new DollarFileObject();

expect(instance.toString()).toBe("dollar file");
expect(generatedDexFiles(instance)).toEqual([]);
});
});
Original file line number Diff line number Diff line change
Expand Up @@ -1630,8 +1630,8 @@ describe("Tests ", function () {
__log("TEST: TestCanParseSignatureWithTypesThatContainsCapitalLettersForPrimitiveTypes");

var formats = java.lang.reflect.Array.newInstance(java.text.NumberFormat.class, 2);
formats[0] = java.text.NumberFormat.getInstance();
formats[1] = java.text.NumberFormat.getIntegerInstance();
formats[0] = java.text.NumberFormat.getInstance(java.util.Locale.US);
formats[1] = java.text.NumberFormat.getIntegerInstance(java.util.Locale.US);
var mf = new java.text.MessageFormat("{0}, {1}")
mf.setFormats(formats);
var arr = mf.parse("123, 4567");
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,11 @@
var NoConstructor = /** @class */ (function (_super) {
__extends(NoConstructor, _super);
function NoConstructor() {
return _super !== null && _super.apply(this, arguments) || this;
}
NoConstructor.prototype.toString = function () {
return "no constructor";
};
return NoConstructor;
}(java.lang.Object));
var Minified=function(e){__extends(Minified,e);function Minified(){return null!==e&&e.apply(this,arguments)||this}Minified.prototype.toString=function(){return"minified"};return Minified}(java.lang.Object);
Original file line number Diff line number Diff line change
@@ -0,0 +1,175 @@
(function () {

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length;
var r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;

if (typeof global.Reflect === "object" && typeof global.Reflect.decorate === "function") {
r = global.Reflect.decorate(decorators, target, key, desc);
}
else {
for (var i = decorators.length - 1; i >= 0; i--) {
if (d = decorators[i]) {
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
}
}
}
return c > 3 && r && Object.defineProperty(target, key, r), r;
};

// For backward compatibility.
var __native = function (thiz) {
// we are setting the __container__ property to the base class when the super method is called
// if the constructor returns the __native(this) call we will use the old implementation
// copying all the properties to the result
// otherwise if we are using the result from the super() method call we won't need such logic
// as thiz already contains the parent properties
// this way we now support both implementations in typescript generated constructors:
// 1: super(); return __native(this);
// 2: return super() || this;
if (thiz.__container__) {
var result = thiz.__proto__;

for (var prop in thiz) {
if (thiz.hasOwnProperty(prop)) {
thiz.__proto__[prop] = thiz[prop];
delete thiz[prop];
}
}

thiz.constructor = undefined;
thiz.__proto__ = undefined;
Object.freeze(thiz);
Object.preventExtensions(thiz);
return result;
} else {
return thiz;
}
};

var __extends = function (Child, Parent) {
var extendNativeClass = !!Parent.extend && (Parent.extend.toString().indexOf("[native code]") > -1);
if (!extendNativeClass) {
__extends_ts(Child, Parent);
return;
}
if (Parent.__isPrototypeImplementationObject) {
throw new Error("Can not extend an already extended native object.");
}

function extend(thiz) {
var child = thiz.__proto__.__child;
if (!child.__extended) {
var parent = thiz.__proto__.__parent;
child.__extended = parent.extend(child.name, child.prototype, true);
// This will deal with "i instanceof child"
child[Symbol.hasInstance] = function (instance) {
return instance instanceof this.__extended;
}
}
return child.__extended;
};

Parent.__activityExtend = function (parent, name, implementationObject) {
__log("__activityExtend called");
return parent.extend(name, implementationObject);
};

Parent.call = function (thiz) {
var Extended = extend(thiz);
thiz.__container__ = true;
if (arguments.length > 1) {
thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(Array.prototype.slice.call(arguments, 1))));
}
else {
thiz.__proto__ = new Extended()
}
return thiz.__proto__;
};

Parent.apply = function (thiz, args) {
var Extended = extend(thiz);
thiz.__container__ = true;
if (args && args.length > 0) {
thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(args)));
}
else {
thiz.__proto__ = new Extended();
}
return thiz.__proto__;
};
__extends_ns(Child, Parent);
Child.__isPrototypeImplementationObject = true;
Child.__proto__ = Parent;
Child.prototype.__parent = Parent;
Child.prototype.__child = Child;
}

var __extends_ts = function (child, parent) {
extendStaticFunctions(child, parent);
assignPrototypeFromParentToChild(parent, child);
};

var __extends_ns = function (child, parent) {
if (!parent.extend) {
assignPropertiesFromParentToChild(parent, child);
}

assignPrototypeFromParentToChild(parent, child);
};

var extendStaticFunctions =
Object.setPrototypeOf
|| (hasInternalProtoProperty() && function (child, parent) { child.__proto__ = parent; })
|| assignPropertiesFromParentToChild;

function hasInternalProtoProperty() {
return { __proto__: [] } instanceof Array;
}

function assignPropertiesFromParentToChild(parent, child) {
for (var property in parent) {
if (parent.hasOwnProperty(property)) {
child[property] = parent[property];
}
}
}

function assignPrototypeFromParentToChild(parent, child) {
function __() {
this.constructor = child;
}

if (parent === null) {
child.prototype = Object.create(null);
} else {
__.prototype = parent.prototype;
child.prototype = new __();
}
}


function JavaProxy(className) {
return function (target) {
var extended = target.extend(className, target.prototype)
extended.name = className;
return extended;
};
}

function Interfaces(interfacesArr) {
return function (target) {
if (interfacesArr instanceof Array) {
// attach interfaces: [] to the object
target.prototype.interfaces = interfacesArr;
}
}
}

Object.defineProperty(global, "__native", { value: __native });
Object.defineProperty(global, "__extends", { value: __extends });
Object.defineProperty(global, "__decorate", { value: __decorate });

global.JavaProxy = JavaProxy;
global.Interfaces = Interfaces;
})()
Original file line number Diff line number Diff line change
Expand Up @@ -352,6 +352,32 @@ describe("parser/js_parser tests", function () {
});
});

it("Generated metadata for a transpiled typescript class without a constructor should contain the super call location", function (done) {
let input = path.normalize(path.join(prefix, "extends_ts_no_constructor", "app")),
generatedJavaClassesRoot = path.normalize(path.join(prefix, "extends_ts_no_constructor", "src", "main", "java"));

clearOutput();

execGradle(input, generatedJavaClassesRoot, function (error, stdout, stderr) {
if (error) {
console.error(`exec error: ${error}`);
return done.fail(error);
}

logExecResult(stdout, stderr)

let bindingsContent = fs.readFileSync(sbgBindingOutoutFile, "utf-8").toString().trim().split('\n');

let locations = bindingsContent.map(line => line.split("*").slice(1, 5).join("*")).sort();
expect(locations).toEqual([
"no_constructor*11*108*Minified",
"no_constructor*4*64*NoConstructor"
]);

done();
});
});

it("Generated metadata for bindings should return proper JavaClass name when there is a static property and double assignment", function (done) {
let input = path.normalize(path.join(prefix, "decorated_double_assignment_ts", "app")),
generatedJavaClassesRoot = path.normalize(path.join(prefix, "decorated_double_assignment_ts", "src", "main", "java"));
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -1136,23 +1136,52 @@ var es5_visitors = (function () {
? matchingNodes[0].declarations[0].init.left
: null;
}

function getReturnSuperCallLineNode(nodes, superIdentifier) {
function isSuperCall(node) {
return (
types.isCallExpression(node) &&
types.isMemberExpression(node.callee) &&
node.callee.object.name === superIdentifier
);
}

for (var i = 0; i < nodes.length; i++) {
var argument = nodes[i].argument;
if (!types.isLogicalExpression(argument)) {
continue;
}
var left = argument.left;
if (isSuperCall(left)) {
return left;
}
if (types.isLogicalExpression(left) && isSuperCall(left.right)) {
return left.right;
}
}
return null;
}
////

if (superVariableIdentifier) {
var possibleVariableDeclarations = [];
var possibleExpressionStatements = [];
var possibleReturnStatements = [];

constructorFunctionScope.body.body.forEach((node) => {
if (types.isVariableDeclaration(node)) {
possibleVariableDeclarations.push(node);
} else if (types.isExpressionStatement(node)) {
possibleExpressionStatements.push(node);
} else if (types.isReturnStatement(node)) {
possibleReturnStatements.push(node);
}
});

if (
possibleVariableDeclarations.length > 0 ||
possibleExpressionStatements.length > 0
possibleExpressionStatements.length > 0 ||
possibleReturnStatements.length > 0
) {
var superCallRHS =
getThisDeclarationSuperCallLineNode(
Expand All @@ -1162,6 +1191,10 @@ var es5_visitors = (function () {
getThisAssignmentSuperCallLineNode(
possibleExpressionStatements,
superVariableIdentifier
) ||
getReturnSuperCallLineNode(
possibleReturnStatements,
superVariableIdentifier
);

if (types.isCallExpression(superCallRHS)) {
Expand Down
Loading
Loading