Fixes and improvements for UglifyJS->SM AST conversion.

* Explicitly forbidden multiple catch clauses as SM-specific feature.
* Simplified describing of UglifyJS->Mozilla AST conversion rules.
* Moved alias rules to single place.
* Removed usage of dynamic type bindings in generated code (speed-up).

lib/mozilla-ast.js

@@ -62,11 +62,15 @@
             });
         },
         TryStatement: function(M) {
+            var handlers = M.handlers || [M.handler];
+            if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {
+                throw new Error("Multiple catch clauses are not supported.");
+            }
             return new AST_Try({
                 start    : my_start_token(M),
                 end      : my_end_token(M),
                 body     : from_moz(M.block).body,
-                bcatch   : from_moz(M.handlers ? M.handlers[0] : M.handler),
+                bcatch   : from_moz(handlers[0]),
                 bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
             });
         },
@@ -146,8 +150,6 @@
                 return new AST_RegExp(args);
             }
         },
-        UnaryExpression: From_Moz_Unary,
-        UpdateExpression: From_Moz_Unary,
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
             return new (  p.type == "LabeledStatement" ? AST_Label
@@ -164,137 +166,8 @@
         }
     };
 
-    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) {
+    MOZ_TO_ME.UpdateExpression =
+    MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) {
         var prefix = "prefix" in M ? M.prefix
             : M.type == "UnaryExpression" ? true : false;
         return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
@@ -335,16 +208,152 @@
     map("NewExpression", AST_New, "callee>expression, arguments@args");
     map("CallExpression", AST_Call, "callee>expression, arguments@args");
 
-    AST_Accessor.prototype.to_mozilla_ast = AST_Function.prototype.to_mozilla_ast;
-
-    AST_Binary.prototype.to_mozilla_ast = function () {
+    def_to_moz(AST_Directive, function To_Moz_Directive(M) {
         return {
-            type: this.operator == "&&" || this.operator == "||" ? "LogicalExpression" : "BinaryExpression",
-            left: to_moz(this.left),
-            operator: this.operator,
-            right: to_moz(this.right)
+            type: "ExpressionStatement",
+            expression: {
+                type: "Literal",
+                value: M.value
+            }
         };
-    };
+    });
+
+    def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) {
+        return {
+            type: "ExpressionStatement",
+            expression: to_moz(M.body)
+        };
+    });
+
+    def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {
+        return {
+            type: "SwitchCase",
+            test: to_moz(M.expression),
+            consequent: M.body.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
+        return {
+            type: "TryStatement",
+            block: to_moz_block(M),
+            handler: to_moz(M.bcatch),
+            guardedHandlers: [],
+            finalizer: to_moz(M.bfinally)
+        };
+    });
+
+    def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
+        return {
+            type: "CatchClause",
+            param: to_moz(M.argname),
+            guard: null,
+            body: to_moz_block(M)
+        };
+    });
+
+    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
+        return {
+            type: "VariableDeclaration",
+            kind: M instanceof AST_Const ? "const" : "var",
+            declarations: M.definitions.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Seq, function To_Moz_SequenceExpression(M) {
+        return {
+            type: "SequenceExpression",
+            expressions: M.to_array().map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
+        var isComputed = M instanceof AST_Sub;
+        return {
+            type: "MemberExpression",
+            object: to_moz(M.expression),
+            computed: isComputed,
+            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property}
+        };
+    });
+
+    def_to_moz(AST_Unary, function To_Moz_Unary(M) {
+        return {
+            type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression",
+            operator: M.operator,
+            prefix: M instanceof AST_UnaryPrefix,
+            argument: to_moz(M.argument)
+        };
+    });
+
+    def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {
+        return {
+            type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression",
+            left: to_moz(M.left),
+            operator: M.operator,
+            right: to_moz(M.right)
+        };
+    });
+
+    def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) {
+        return {
+            type: "ObjectExpression",
+            properties: M.properties.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
+        var key;
+        if (is_identifier_string(M.key) && !RESERVED_WORDS(M.key)) {
+            key = {type: "Identifier", name: M.key};
+        } else {
+            key = {type: "Literal", value: M.key};
+        }
+        var kind;
+        if (M instanceof AST_ObjectKeyVal) {
+            kind = "init";
+        } else
+        if (M instanceof AST_ObjectGetter) {
+            kind = "get";
+        } else
+        if (M instanceof AST_ObjectSetter) {
+            kind = "set";
+        }
+        return {
+            type: "Property",
+            kind: kind,
+            key: key,
+            value: to_moz(M.value)
+        };
+    });
+
+    def_to_moz(AST_Symbol, function To_Moz_Identifier(M) {
+        return {
+            type: "Identifier",
+            name: M.name
+        };
+    });
+
+    def_to_moz(AST_Constant, function To_Moz_Literal(M) {
+        return {
+            type: "Literal",
+            value: M.value
+        };
+    });
+
+    def_to_moz(AST_Atom, function To_Moz_Atom(M) {
+        return {
+            type: "Identifier",
+            name: String(M.value)
+        };
+    });
+
+    AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+    AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+    AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null });
+
+    AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast);
+    AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast);
 
     /* -----[ tools ]----- */
 
@@ -372,6 +381,78 @@
         });
     };
 
+    function map(moztype, mytype, propmap) {
+        var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
+        moz_to_me += "return new " + mytype.name + "({\n" +
+            "start: my_start_token(M),\n" +
+            "end: my_end_token(M)";
+
+        var me_to_moz = "function To_Moz_" + moztype + "(M){\n";
+        me_to_moz += "return {\n" +
+            "type: " + JSON.stringify(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[1], how = m[2], my = m[3];
+            moz_to_me += ",\n" + my + ": ";
+            me_to_moz += ",\n" + moz + ": ";
+            switch (how) {
+                case "@":
+                    moz_to_me += "M." + moz + ".map(from_moz)";
+                    me_to_moz += "M." +  my + ".map(to_moz)";
+                    break;
+                case ">":
+                    moz_to_me += "from_moz(M." + moz + ")";
+                    me_to_moz += "to_moz(M." + my + ")";
+                    break;
+                case "=":
+                    moz_to_me += "M." + moz;
+                    me_to_moz += "M." + my;
+                    break;
+                case "%":
+                    moz_to_me += "from_moz(M." + moz + ").body";
+                    me_to_moz += "to_moz_block(M)";
+                    break;
+                default:
+                    throw new Error("Can't understand operator in propmap: " + prop);
+            }
+        });
+
+        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("my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
+            my_start_token, my_end_token, from_moz
+        );
+        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block
+        );
+        MOZ_TO_ME[moztype] = moz_to_me;
+        def_to_moz(mytype, me_to_moz);
+    };
+
+    var FROM_MOZ_STACK = null;
+
+    function from_moz(node) {
+        FROM_MOZ_STACK.push(node);
+        var ret = node != null ? MOZ_TO_ME[node.type](node) : null;
+        FROM_MOZ_STACK.pop();
+        return ret;
+    };
+
+    AST_Node.from_mozilla_ast = function(node){
+        var save_stack = FROM_MOZ_STACK;
+        FROM_MOZ_STACK = [];
+        var ast = from_moz(node);
+        FROM_MOZ_STACK = save_stack;
+        return ast;
+    };
+
     function moz_sub_loc(token) {
         return token.line ? {
             line: token.line,
@@ -397,80 +478,21 @@
         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[1], how = m[2], my = m[3];
-            moz_to_me += ",\n" + my + ": ";
-            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);
-            }
+    function def_to_moz(mytype, handler) {
+        mytype.DEFMETHOD("to_mozilla_ast", function() {
+            return set_moz_loc(this, handler(this));
         });
-
-        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
-        );
-        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, TO_MOZ_STACK = null;
-
-    function from_moz(node) {
-        FROM_MOZ_STACK.push(node);
-        var ret = node != null ? MOZ_TO_ME[node.type](node) : null;
-        FROM_MOZ_STACK.pop();
-        return ret;
-    };
-
-    AST_Node.from_mozilla_ast = function(node){
-        var save_stack = FROM_MOZ_STACK;
-        FROM_MOZ_STACK = [];
-        var ast = from_moz(node);
-        FROM_MOZ_STACK = save_stack;
-        return ast;
     };
 
     function to_moz(node) {
         return node != null ? node.to_mozilla_ast() : null;
     };
 
+    function to_moz_block(node) {
+        return {
+            type: "BlockStatement",
+            body: node.body.map(to_moz)
+        };
+    };
+
 })();