[Pkg-javascript-commits] [uglifyjs] 03/26: Improved UglifyJS<->SpiderMonkey AST conversions.
Jonas Smedegaard
dr at jones.dk
Tue May 19 00:02:20 UTC 2015
This is an automated email from the git hooks/post-receive script.
js pushed a commit to tag v2.4.16
in repository uglifyjs.
commit 0e3ff1f970b173dddc4f624a8935925ea4cfca3e
Author: Ingvar Stepanyan <me at rreverser.com>
Date: Fri Aug 1 15:13:31 2014 +0300
Improved UglifyJS<->SpiderMonkey AST conversions.
* Added directives recognition in SM AST.
* Moved semi-standard SM `Property` type to separate handler.
* Added `const` recognition from SM AST.
* Removed redundant `this`-as-identifier recognition.
* Removed redundant rules for abstract SM types.
* Described `CatchClause` using string syntax.
* Added support for semi-standard `range` tuple as location source.
* Added back-conversion support (to be improved).
---
lib/mozilla-ast.js | 339 +++++++++++++++++++++++++++++++++++++++++++----------
1 file changed, 274 insertions(+), 65 deletions(-)
diff --git a/lib/mozilla-ast.js b/lib/mozilla-ast.js
index bc24dfd..2d35fb2 100644
--- a/lib/mozilla-ast.js
+++ b/lib/mozilla-ast.js
@@ -46,7 +46,22 @@
(function(){
var MOZ_TO_ME = {
- TryStatement : function(M) {
+ ExpressionStatement: function(M) {
+ var expr = M.expression;
+ if (expr.type === "Literal" && typeof expr.value === "string") {
+ return new AST_Directive({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ value: expr.value
+ });
+ }
+ return new AST_SimpleStatement({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ body: from_moz(expr)
+ });
+ },
+ TryStatement: function(M) {
return new AST_Try({
start : my_start_token(M),
end : my_end_token(M),
@@ -55,44 +70,40 @@
bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
});
},
- CatchClause : function(M) {
- return new AST_Catch({
- start : my_start_token(M),
- end : my_end_token(M),
- argname : from_moz(M.param),
- body : from_moz(M.body).body
- });
+ Property: function(M) {
+ var key = M.key;
+ var name = key.type == "Identifier" ? key.name : key.value;
+ var args = {
+ start : my_start_token(key),
+ end : my_end_token(M.value),
+ key : name,
+ value : from_moz(M.value)
+ };
+ switch (M.kind) {
+ case "init":
+ return new AST_ObjectKeyVal(args);
+ case "set":
+ args.value.name = from_moz(key);
+ return new AST_ObjectSetter(args);
+ case "get":
+ args.value.name = from_moz(key);
+ return new AST_ObjectGetter(args);
+ }
},
- ObjectExpression : function(M) {
+ ObjectExpression: function(M) {
return new AST_Object({
start : my_start_token(M),
end : my_end_token(M),
properties : M.properties.map(function(prop){
- var key = prop.key;
- var name = key.type == "Identifier" ? key.name : key.value;
- var args = {
- start : my_start_token(key),
- end : my_end_token(prop.value),
- key : name,
- value : from_moz(prop.value)
- };
- switch (prop.kind) {
- case "init":
- return new AST_ObjectKeyVal(args);
- case "set":
- args.value.name = from_moz(key);
- return new AST_ObjectSetter(args);
- case "get":
- args.value.name = from_moz(key);
- return new AST_ObjectGetter(args);
- }
+ prop.type = "Property";
+ return from_moz(prop)
})
});
},
- SequenceExpression : function(M) {
+ SequenceExpression: function(M) {
return AST_Seq.from_array(M.expressions.map(from_moz));
},
- MemberExpression : function(M) {
+ MemberExpression: function(M) {
return new (M.computed ? AST_Sub : AST_Dot)({
start : my_start_token(M),
end : my_end_token(M),
@@ -100,7 +111,7 @@
expression : from_moz(M.object)
});
},
- SwitchCase : function(M) {
+ SwitchCase: function(M) {
return new (M.test ? AST_Case : AST_Default)({
start : my_start_token(M),
end : my_end_token(M),
@@ -108,7 +119,14 @@
body : M.consequent.map(from_moz)
});
},
- Literal : function(M) {
+ VariableDeclaration: function(M) {
+ return new (M.kind === "const" ? AST_Const : AST_Var)({
+ start : my_start_token(M),
+ end : my_end_token(M),
+ definitions : M.declarations.map(from_moz)
+ });
+ },
+ Literal: function(M) {
var val = M.value, args = {
start : my_start_token(M),
end : my_end_token(M)
@@ -132,8 +150,7 @@
UpdateExpression: From_Moz_Unary,
Identifier: function(M) {
var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
- return new (M.name == "this" ? AST_This
- : p.type == "LabeledStatement" ? AST_Label
+ return new ( p.type == "LabeledStatement" ? AST_Label
: p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
: p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
: p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
@@ -147,6 +164,136 @@
}
};
+ AST_Directive.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "ExpressionStatement",
+ expression: set_moz_loc(this, {
+ type: "Literal",
+ value: this.value
+ })
+ });
+ };
+
+ AST_SimpleStatement.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "ExpressionStatement",
+ expression: to_moz(this.body)
+ });
+ };
+
+ AST_SwitchBranch.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "SwitchCase",
+ test: to_moz(this.expression),
+ consequent: this.body.map(to_moz)
+ });
+ };
+
+ AST_Try.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "TryStatement",
+ block: {
+ type: "BlockStatement",
+ body: this.body.map(to_moz)
+ },
+ handler: to_moz(this.bcatch),
+ finalizer: this.bfinally ? this.bfinally.body.map(to_moz) : null
+ });
+ };
+
+ AST_Definitions.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "VariableDeclaration",
+ kind: this instanceof AST_Const ? "const" : "var",
+ declarations: this.definitions.map(to_moz)
+ });
+ };
+
+ AST_Seq.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "SequenceExpression",
+ expressions: this.to_array().map(to_moz)
+ });
+ };
+
+ AST_PropAccess.prototype.to_mozilla_ast = function() {
+ var isComputed = this instanceof AST_Sub;
+ return set_moz_loc(this, {
+ type: "MemberExpression",
+ object: to_moz(this.expression),
+ computed: isComputed,
+ property: isComputed ? to_moz(this.property) : {type: "Identifier", name: this.property}
+ });
+ };
+
+ AST_Unary.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: this.operator == "++" || this.operator == "--" ? "UpdateExpression" : "UnaryExpression",
+ operator: this.operator,
+ prefix: this instanceof AST_UnaryPrefix,
+ argument: to_moz(this.argument)
+ });
+ };
+
+ AST_Object.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "ObjectExpression",
+ properties: this.properties.map(to_moz)
+ });
+ };
+
+ AST_ObjectProperty.prototype.to_mozilla_ast = function() {
+ var key;
+ if (is_identifier_string(this.key) && !RESERVED_WORDS(this.key)) {
+ key = {type: "Identifier", name: this.key};
+ } else {
+ key = {type: "Literal", value: this.key};
+ }
+ var kind;
+ if (this instanceof AST_ObjectKeyVal) {
+ kind = "init";
+ } else
+ if (this instanceof AST_ObjectGetter) {
+ kind = "get";
+ } else
+ if (this instanceof AST_ObjectSetter) {
+ kind = "set";
+ }
+ return set_moz_loc(this, {
+ type: "Property",
+ kind: kind,
+ key: key,
+ value: to_moz(this.value)
+ });
+ };
+
+ AST_Symbol.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "Identifier",
+ name: this.name
+ });
+ };
+
+ AST_Null.prototype.to_mozilla_ast =
+ AST_Boolean.prototype.to_mozilla_ast =
+ AST_Constant.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "Literal",
+ value: this.value
+ });
+ };
+
+ AST_Atom.prototype.to_mozilla_ast = function() {
+ return set_moz_loc(this, {
+ type: "Identifier",
+ name: String(this.value)
+ });
+ };
+
+ AST_Hole.prototype.to_mozilla_ast = function() {
+ return null;
+ };
+
function From_Moz_Unary(M) {
var prefix = "prefix" in M ? M.prefix
: M.type == "UnaryExpression" ? true : false;
@@ -158,14 +305,9 @@
});
};
- var ME_TO_MOZ = {};
-
- map("Node", AST_Node);
map("Program", AST_Toplevel, "body at body");
- map("Function", AST_Function, "id>name, params at argnames, body%body");
map("EmptyStatement", AST_EmptyStatement);
map("BlockStatement", AST_BlockStatement, "body at body");
- map("ExpressionStatement", AST_SimpleStatement, "expression>body");
map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
map("BreakStatement", AST_Break, "label>label");
@@ -180,74 +322,137 @@
map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
map("DebuggerStatement", AST_Debugger);
map("FunctionDeclaration", AST_Defun, "id>name, params at argnames, body%body");
- map("VariableDeclaration", AST_Var, "declarations at definitions");
map("VariableDeclarator", AST_VarDef, "id>name, init>value");
+ map("CatchClause", AST_Catch, "param>argname, body%body");
map("ThisExpression", AST_This);
map("ArrayExpression", AST_Array, "elements at elements");
map("FunctionExpression", AST_Function, "id>name, params at argnames, body%body");
map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
- map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
+ map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
map("NewExpression", AST_New, "callee>expression, arguments at args");
map("CallExpression", AST_Call, "callee>expression, arguments at args");
+ AST_Accessor.prototype.to_mozilla_ast = AST_Function.prototype.to_mozilla_ast;
+
+ AST_Binary.prototype.to_mozilla_ast = function () {
+ return {
+ type: this.operator == "&&" || this.operator == "||" ? "LogicalExpression" : "BinaryExpression",
+ left: to_moz(this.left),
+ operator: this.operator,
+ right: to_moz(this.right)
+ };
+ };
+
/* -----[ tools ]----- */
function my_start_token(moznode) {
+ var loc = moznode.loc;
+ var range = moznode.range;
return new AST_Token({
- file : moznode.loc && moznode.loc.source,
- line : moznode.loc && moznode.loc.start.line,
- col : moznode.loc && moznode.loc.start.column,
- pos : moznode.start,
- endpos : moznode.start
+ file : loc && loc.source,
+ line : loc && loc.start.line,
+ col : loc && loc.start.column,
+ pos : range ? range[0] : moznode.start,
+ endpos : range ? range[0] : moznode.start
});
};
function my_end_token(moznode) {
+ var loc = moznode.loc;
+ var range = moznode.range;
return new AST_Token({
- file : moznode.loc && moznode.loc.source,
- line : moznode.loc && moznode.loc.end.line,
- col : moznode.loc && moznode.loc.end.column,
- pos : moznode.end,
- endpos : moznode.end
+ file : loc && loc.source,
+ line : loc && loc.end.line,
+ col : loc && loc.end.column,
+ pos : range ? range[1] : moznode.end,
+ endpos : range ? range[1] : moznode.end
});
};
+ function moz_sub_loc(token) {
+ return token.line ? {
+ line: token.line,
+ column: token.col
+ } : null;
+ };
+
+ function set_moz_loc(mynode, moznode) {
+ var start = mynode.start;
+ var end = mynode.end;
+ if (start.pos != null && end.pos != null) {
+ moznode.range = [start.pos, end.pos];
+ }
+ if (start.line) {
+ moznode.loc = {
+ start: moz_sub_loc(start),
+ end: moz_sub_loc(end)
+ };
+ if (start.file) {
+ moznode.loc.source = start.file;
+ }
+ }
+ return moznode;
+ };
+
function map(moztype, mytype, propmap) {
var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
moz_to_me += "return new mytype({\n" +
"start: my_start_token(M),\n" +
"end: my_end_token(M)";
+ var me_to_moz = "function To_Moz_" + moztype + "(){\n";
+ me_to_moz += "return set_moz_loc(this, {\n" +
+ "type: moztype";
+
if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop){
var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
if (!m) throw new Error("Can't understand property map: " + prop);
- var moz = "M." + m[1], how = m[2], my = m[3];
+ var moz = m[1], how = m[2], my = m[3];
moz_to_me += ",\n" + my + ": ";
- if (how == "@") {
- moz_to_me += moz + ".map(from_moz)";
- } else if (how == ">") {
- moz_to_me += "from_moz(" + moz + ")";
- } else if (how == "=") {
- moz_to_me += moz;
- } else if (how == "%") {
- moz_to_me += "from_moz(" + moz + ").body";
- } else throw new Error("Can't understand operator in propmap: " + prop);
+ me_to_moz += ",\n" + moz + ": ";
+ switch (how) {
+ case "@":
+ moz_to_me += "M." + moz + ".map(from_moz)";
+ me_to_moz += "this." + my + ".map(to_moz)";
+ break;
+ case ">":
+ moz_to_me += "from_moz(M." + moz + ")";
+ me_to_moz += "to_moz(this." + my + ")";
+ break;
+ case "=":
+ moz_to_me += "M." + moz;
+ me_to_moz += "this." + my;
+ break;
+ case "%":
+ moz_to_me += "from_moz(M." + moz + ").body";
+ me_to_moz += "{type: \"BlockStatement\", body: this." + my + ".map(to_moz)}";
+ break;
+ default:
+ throw new Error("Can't understand operator in propmap: " + prop);
+ }
});
- moz_to_me += "\n})}";
- // moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
- // console.log(moz_to_me);
+ moz_to_me += "\n})\n}";
+ me_to_moz += "\n})\n}";
+
+ moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
+ me_to_moz = parse(me_to_moz).print_to_string({ beautify: true });
+ //console.log(moz_to_me);
moz_to_me = new Function("mytype", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
mytype, my_start_token, my_end_token, from_moz
);
- return MOZ_TO_ME[moztype] = moz_to_me;
+ me_to_moz = new Function("moztype", "set_moz_loc", "to_moz", "return(" + me_to_moz + ")")(
+ moztype, set_moz_loc, to_moz
+ );
+ MOZ_TO_ME[moztype] = moz_to_me;
+ mytype.prototype.to_mozilla_ast = me_to_moz;
};
- var FROM_MOZ_STACK = null;
+ var FROM_MOZ_STACK = null, TO_MOZ_STACK = null;
function from_moz(node) {
FROM_MOZ_STACK.push(node);
@@ -264,4 +469,8 @@
return ast;
};
+ function to_moz(node) {
+ return node != null ? node.to_mozilla_ast() : null;
+ };
+
})();
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/uglifyjs.git
More information about the Pkg-javascript-commits
mailing list