Join assignment

lib/process.js

@@ -128,13 +128,17 @@ function ast_walker() {
                         return [ this[0], walk(cond), walk(t), walk(e) ];
                 },
                 "assign": function(op, lvalue, rvalue) {
-                        return [ this[0], op, walk(lvalue), walk(rvalue) ];
+                        rvalue = walk(rvalue)
+                        lvalue = walk(lvalue)
+                        return [ this[0], op, lvalue, rvalue ];
                 },
                 "dot": function(expr) {
                         return [ this[0], walk(expr) ].concat(slice(arguments, 1));
                 },
                 "call": function(expr, args) {
-                        return [ this[0], walk(expr), MAP(args, walk) ];
+                        args = MAP(args, walk)
+                        expr = walk(expr)
+                        return [ this[0], expr, args ];
                 },
                 "function": function(name, args, body) {
                         return [ this[0], name, args.slice(), MAP(body, walk) ];
@@ -249,6 +253,7 @@ function ast_walker() {
         };
 
         return {
+                default_walkers: walkers,
                 walk: walk,
                 dive: dive,
                 with_walkers: with_walkers,
@@ -983,6 +988,81 @@ function ast_lift_variables(ast) {
         });
 };
 
+function mergeAssignSimple(ast, options) {
+  var w = ast_walker()
+    , walk = w.walk
+    , mergeable = null
+    , obsolete = [];
+
+  function arrayCopy(arr) {
+    var result = [];
+    for (var i=0; i<arr.length; i++) {
+      result.push(arr[i]);
+    }
+    return result;
+  }
+
+  function deepExterminateAll(arr, targets) {
+    for (var i=0; i<arr.length; i++) {
+      if (~targets.indexOf(arr[i])) {
+        arr.splice(i, 1);
+        i--;
+        continue;
+      }
+      if (Array.isArray(arr[i])) {
+        deepExterminateAll(arr[i], targets);
+      }
+    }
+  }
+
+  function handleSimpleLiteral(value) {
+    var type = this[0];
+    if (mergeable && mergeable.type === type && mergeable.value === value) {
+      var stack = w.stack();
+      obsolete.push(mergeable.statement);
+      var result = mergeable.assign;
+      mergeable = null;
+      return arrayCopy(result);
+    } else {
+      return [type, value];
+    }
+  }
+
+  function handleStatement(expr) {
+    var result = [this[0], walk(expr)]
+    mergeable = null
+    if (expr[0] === "assign" && expr[1] === true && expr[3][0] in {string:1,num:1,atom:1}) {
+      // this is a simple-value assigning statement
+      mergeable = {statement: result, type: expr[3][0], value: expr[3][1], assign: expr}
+    }
+    return result;
+  }
+
+  var walkers =
+  { string: handleSimpleLiteral
+  , num: handleSimpleLiteral
+  , atom: handleSimpleLiteral /*false,true,null,undefined*/
+  , stat: handleStatement
+  };
+
+  Object.keys(w.default_walkers).forEach(function(type) {
+    if (!walkers[type]) {
+      walkers[type] = function() {
+        var result = w.default_walkers[type].apply(this, arguments);
+        mergeable = null;
+        return result;
+      };
+    }
+  });
+
+  w.with_walkers(walkers, function() {
+      ast = walk(ast);
+  });
+
+  deepExterminateAll(ast, obsolete);
+  return ast;
+}
+
 function ast_squeeze(ast, options) {
         options = defaults(options, {
                 make_seqs   : true,
@@ -1322,6 +1402,7 @@ function ast_squeeze(ast, options) {
         }, function() {
                 for (var i = 0; i < 2; ++i) {
                         ast = prepare_ifs(ast);
+                        ast = mergeAssignSimple(ast);
                         ast = ast_add_scope(ast);
                         ast = walk(ast);
                 }