dart2js cps: Generate increment and compound operators.

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library code_generator;
 
 import 'glue.dart';
 
 import '../../closure.dart' show
     ClosureClassElement;
 import '../../common.dart';
 import '../../common/codegen.dart' show
     CodegenRegistry;
 import '../../constants/values.dart';
 import '../../dart_types.dart';
 import '../../elements/elements.dart';
 import '../../io/source_information.dart' show
     SourceInformation;
 import '../../js/js.dart' as js;
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../tree_ir/tree_ir_nodes.dart' show
     BuiltinMethod,
-    BuiltinOperator;
+    BuiltinOperator,
+    isCompoundableOperator;
 import '../../types/types.dart' show
     TypeMask;
 import '../../universe/call_structure.dart' show
     CallStructure;
 import '../../universe/selector.dart' show
     Selector;
 import '../../universe/use.dart' show
     DynamicUse,
     StaticUse,
     TypeUse;
@@ skipping 464 matching lines @@
 
   @override
   js.Expression visitVariableUse(tree_ir.VariableUse node) {
     return buildVariableAccess(node.variable);
   }
 
   js.Expression buildVariableAccess(tree_ir.Variable variable) {
     return new js.VariableUse(getVariableName(variable));
   }
 
+  /// Returns the JS operator for the given built-in operator for use in a
+  /// compound assignment (not including the '=' sign).
+  String getAsCompoundOperator(BuiltinOperator operator) {
+    switch (operator) {
+      case BuiltinOperator.NumAdd:
+      case BuiltinOperator.StringConcatenate:
+        return '+';
+      case BuiltinOperator.NumSubtract:
+        return '-';
+      case BuiltinOperator.NumMultiply:
+        return '*';
+      case BuiltinOperator.NumDivide:
+        return '/';
+      case BuiltinOperator.NumRemainder:
+        return '%';
+      default:
+        throw 'Not a compoundable operator: $operator';
+    }
+  }
+
+  bool isCompoundableBuiltin(tree_ir.Expression exp) {
+    return exp is tree_ir.ApplyBuiltinOperator &&
+           exp.arguments.length == 2 &&
+           isCompoundableOperator(exp.operator);
+  }
+
+  bool isOneConstant(tree_ir.Expression exp) {
+    return exp is tree_ir.Constant && exp.value.isOne;
+  }
+
+  js.Expression makeAssignment(
+      js.Expression leftHand,
+      tree_ir.Expression value,
+      {BuiltinOperator compound}) {
+    if (isOneConstant(value)) {
+      if (compound == BuiltinOperator.NumAdd) {
+        return new js.Prefix('++', leftHand);
+      }
+      if (compound == BuiltinOperator.NumSubtract) {
+        return new js.Prefix('--', leftHand);
+      }
+    }
+    if (compound != null) {
+      return new js.Assignment.compound(leftHand,
+          getAsCompoundOperator(compound), visitExpression(value));
+    }
+    return new js.Assignment(leftHand, visitExpression(value));
+  }
+
   @override
   js.Expression visitAssign(tree_ir.Assign node) {
-    return new js.Assignment(
-        buildVariableAccess(node.variable),
-        visitExpression(node.value));
+    js.Expression variable = buildVariableAccess(node.variable);
+    if (isCompoundableBuiltin(node.value)) {
+      tree_ir.ApplyBuiltinOperator rhs = node.value;
+      tree_ir.Expression left = rhs.arguments[0];
+      tree_ir.Expression right = rhs.arguments[1];
+      if (left is tree_ir.VariableUse && left.variable == node.variable) {
+        return makeAssignment(variable, right, compound: rhs.operator);
+      }
+    }
+    return makeAssignment(variable, node.value);
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
     tree_ir.Statement next = fallthrough.target;
     if (node.target.binding == next ||
         next is tree_ir.Continue && node.target == next.target) {
       // Fall through to continue target or to equivalent continue.
       fallthrough.use();
     } else if (node.target.binding == shortContinue.target) {
@@ skipping 293 matching lines @@
 
   @override
   js.Expression visitGetField(tree_ir.GetField node) {
     registry.registerStaticUse(new StaticUse.fieldGet(node.field));
     return new js.PropertyAccess(
         visitExpression(node.object),
         glue.instanceFieldPropertyName(node.field));
   }
 
   @override
-  js.Assignment visitSetField(tree_ir.SetField node) {
+  js.Expression visitSetField(tree_ir.SetField node) {
     registry.registerStaticUse(new StaticUse.fieldSet(node.field));
     js.PropertyAccess field =
         new js.PropertyAccess(
             visitExpression(node.object),
             glue.instanceFieldPropertyName(node.field));
-    return new js.Assignment(field, visitExpression(node.value));
+    return makeAssignment(field, node.value, compound: node.compound);
   }
 
   @override
   js.Expression visitGetStatic(tree_ir.GetStatic node) {
     assert(node.element is FieldElement || node.element is FunctionElement);
     if (node.element is FunctionElement) {
       // Tear off a method.
       registry.registerStaticUse(
           new StaticUse.staticTearOff(node.element.declaration));
       return glue.isolateStaticClosureAccess(node.element);
@@ skipping 29 matching lines @@
 
   @override
   js.Expression visitGetIndex(tree_ir.GetIndex node) {
     return new js.PropertyAccess(
         visitExpression(node.object),
         visitExpression(node.index));
   }
 
   @override
   js.Expression visitSetIndex(tree_ir.SetIndex node) {
-    return js.js('#[#] = #',
-        [visitExpression(node.object),
-         visitExpression(node.index),
-         visitExpression(node.value)]);
+    js.Expression index = new js.PropertyAccess(
+        visitExpression(node.object), visitExpression(node.index));
+    return makeAssignment(index, node.value, compound: node.compound);
   }
 
   js.Expression buildStaticHelperInvocation(
       FunctionElement helper,
       List<js.Expression> arguments,
       {SourceInformation sourceInformation}) {
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(arguments.length)));
     return buildStaticInvoke(
         helper, arguments, sourceInformation: sourceInformation);
@@ skipping 262 matching lines @@
   void registerDefaultParameterValues(ExecutableElement element) {
     if (element is! FunctionElement) return;
     FunctionElement function = element;
     if (function.isStatic) return; // Defaults are inlined at call sites.
     function.functionSignature.forEachOptionalParameter((param) {
       ConstantValue constant = glue.getDefaultParameterValue(param);
       registry.registerCompileTimeConstant(constant);
     });
   }
 }