dart2js cps: Streamline expressions and primitives.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 996 matching lines @@
   /// [function].
   ir.Primitive buildStaticFunctionGet(MethodElement function,
                                       {SourceInformation sourceInformation}) {
     return addPrimitive(new ir.GetStatic(function, sourceInformation));
   }
 
   /// Create a write access to the static [field] with the [value].
   ir.Primitive buildStaticFieldSet(FieldElement field,
                                    ir.Primitive value,
                                    [SourceInformation sourceInformation]) {
-    add(new ir.SetStatic(field, value, sourceInformation));
+    addPrimitive(new ir.SetStatic(field, value, sourceInformation));
     return value;
   }
 
   /// Create a setter invocation of the static [setter] with the [value].
   ir.Primitive buildStaticSetterSet(MethodElement setter,
                                     ir.Primitive value,
                                     {SourceInformation sourceInformation}) {
     Selector selector = new Selector.setter(setter.name, setter.library);
     _buildInvokeStatic(
         setter, selector, <ir.Primitive>[value], sourceInformation);
@@ skipping 1256 matching lines @@
   }
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
   void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     state.functionParameters.add(parameter);
     ClosureLocation location = state.boxedVariables[parameterElement];
     if (location != null) {
-      add(new ir.SetField(environment.lookup(location.box),
-                          location.field,
-                          parameter));
+      addPrimitive(new ir.SetField(
+          environment.lookup(location.box),
+          location.field,
+          parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
   void _createThisParameter() {
     assert(state.thisParameter == null);
     if (Elements.isStaticOrTopLevel(state.currentElement)) return;
     if (state.currentElement.isLocal) return;
     state.thisParameter =
         new ir.Parameter(new ThisParameterLocal(state.currentElement));
   }
 
   void declareLocalVariable(LocalElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullConstant();
     }
     ClosureLocation location = state.boxedVariables[variableElement];
     if (location != null) {
-      add(new ir.SetField(environment.lookup(location.box),
-                          location.field,
-                          initialValue));
+      addPrimitive(new ir.SetField(
+          environment.lookup(location.box),
+          location.field,
+          initialValue));
     } else if (isInMutableVariable(variableElement)) {
-      add(new ir.LetMutable(getMutableVariable(variableElement),
-                            initialValue));
+      add(new ir.LetMutable(
+          getMutableVariable(variableElement),
+          initialValue));
     } else {
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
     }
   }
 
   /// Add [functionElement] to the environment with provided [definition].
   void declareLocalFunction(LocalFunctionElement functionElement,
                             ClosureClassElement classElement,
                             SourceInformation sourceInformation) {
@@ skipping 32 matching lines @@
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] variable or parameter with the provided
   /// [value].
   ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
     ClosureLocation location = state.boxedVariables[local];
     if (location != null) {
-      add(new ir.SetField(environment.lookup(location.box),
-                          location.field,
-                          value));
+      addPrimitive(new ir.SetField(
+          environment.lookup(location.box),
+          location.field,
+          value));
     } else if (isInMutableVariable(local)) {
-      add(new ir.SetMutableVariable(getMutableVariable(local), value));
+      addPrimitive(new ir.SetMutableVariable(
+          getMutableVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   /// Called before building the initializer of a for-loop.
   ///
   /// The loop variables will subsequently be declared using
@@ skipping 23 matching lines @@
     if (scope == null) return;
     // If there are no boxed loop variables, then the box is created inside the
     // body, so there is no need to explicitly renew it.
     if (scope.boxedLoopVariables.isEmpty) return;
     ir.Primitive box = environment.lookup(scope.box);
     ir.Primitive newBox = addPrimitive(new ir.CreateBox());
     newBox.useElementAsHint(scope.box);
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
       ir.Primitive value = addPrimitive(new ir.GetField(box, location.field));
-      add(new ir.SetField(newBox, location.field, value));
+      addPrimitive(new ir.SetField(newBox, location.field, value));
     }
     environment.update(scope.box, newBox);
   }
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis() {
     if (state.enclosingThis != null) return state.enclosingThis;
     assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
   ir.Primitive buildFieldGet(ir.Primitive receiver, FieldElement target) {
     return addPrimitive(new ir.GetField(receiver, target));
   }
 
   void buildFieldSet(ir.Primitive receiver,
                      FieldElement target,
                      ir.Primitive value) {
-    add(new ir.SetField(receiver, target, value));
+    addPrimitive(new ir.SetField(receiver, target, value));
   }
 
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
-    add(new ir.SetField(buildThis(), target, value));
+    addPrimitive(new ir.SetField(buildThis(), target, value));
     return value;
   }
 
   ir.Primitive buildInvokeDirectly(FunctionElement target,
                                    ir.Primitive receiver,
                                    List<ir.Primitive> arguments,
                                    {SourceInformation sourceInformation}) {
     assert(isOpen);
     Selector selector =
         new Selector.call(target.name, target.library, arguments.length);
@@ skipping 290 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }