Add a helper to add a LetPrim node for a new primitive node.

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 '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 405 matching lines @@
     return parameter;
   }
 
   /// Adds the constant [variableElement] to the environment with [value] as its
   /// constant value.
   void declareLocalConstant(LocalVariableElement variableElement,
                             ConstantExpression value) {
     state.localConstants.add(new ConstDeclaration(variableElement, value));
   }
 
-  // Plug an expression into the 'hole' in the context being accumulated.  The
-  // empty context (just a hole) is represented by root (and current) being
-  // null.  Since the hole in the current context is filled by this function,
-  // the new hole must be in the newly added expression---which becomes the
-  // new value of current.
+  /// Plug an expression into the 'hole' in the context being accumulated.  The
+  /// empty context (just a hole) is represented by root (and current) being
+  /// null.  Since the hole in the current context is filled by this function,
+  /// the new hole must be in the newly added expression---which becomes the
+  /// new value of current.
   void add(ir.Expression expr) {
     assert(isOpen);
     if (_root == null) {
       _root = _current = expr;
     } else {
       _current = _current.plug(expr);
     }
   }
 
+  /// Create and add a new [LetPrim] for [primitive].
+  ir.Primitive addPrimitive(ir.Primitive primitive) {
+    add(new ir.LetPrim(primitive));
+    return primitive;
+  }
+
   ir.Primitive _continueWithExpression(ir.Expression build(ir.Continuation k)) {
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression expression = build(k);
     add(new ir.LetCont(k, expression));
     return v;
   }
 
   ir.Primitive _buildInvokeStatic(Element element,
                                   Selector selector,
@@ skipping 28 matching lines @@
     Selector callSelector = new Selector.callClosure(
         selector.argumentCount,
         selector.namedArguments);
     return _buildInvokeDynamic(target, callSelector, arguments);
   }
 
 
   /// Create a constant literal from [constant].
   ir.Constant buildConstantLiteral(ConstantExpression constant) {
     assert(isOpen);
-    ir.Constant prim = new ir.Constant(constant);
-    add(new ir.LetPrim(prim));
-    return prim;
+    return addPrimitive(new ir.Constant(constant));
   }
 
   // Helper for building primitive literals.
   ir.Constant _buildPrimitiveConstant(PrimitiveConstantValue constant) {
     return buildConstantLiteral(new PrimitiveConstantExpression(constant));
   }
 
   /// Create an integer literal.
   ir.Constant buildIntegerLiteral(int value) {
     return _buildPrimitiveConstant(state.constantSystem.createInt(value));
@@ skipping 18 matching lines @@
   ir.Constant buildStringLiteral(String value) {
     return _buildPrimitiveConstant(
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Creates a non-constant list literal of the provided [type] and with the
   /// provided [values].
   ir.Primitive buildListLiteral(InterfaceType type,
                                 Iterable<ir.Primitive> values) {
     assert(isOpen);
-    ir.Primitive result = new ir.LiteralList(type, values);
-    add(new ir.LetPrim(result));
-    return result;
+    return addPrimitive(new ir.LiteralList(type, values));
   }
 
   /// Creates a non-constant map literal of the provided [type] and with the
   /// entries build from the [keys] and [values] using [build].
   ir.Primitive buildMapLiteral(InterfaceType type,
                                Iterable keys,
                                Iterable values,
                                BuildFunction build) {
     assert(isOpen);
     List<ir.LiteralMapEntry> entries = <ir.LiteralMapEntry>[];
     Iterator key = keys.iterator;
     Iterator value = values.iterator;
     while (key.moveNext() && value.moveNext()) {
       entries.add(new ir.LiteralMapEntry(
           build(key.current), build(value.current)));
     }
     assert(!key.moveNext() && !value.moveNext());
-    ir.Primitive result = new ir.LiteralMap(type, entries);
-    add(new ir.LetPrim(result));
-    return result;
+    return addPrimitive(new ir.LiteralMap(type, entries));
   }
 
   /// Creates a conditional expression with the provided [condition] where the
   /// then and else expression are created through the [buildThenExpression] and
   /// [buildElseExpression] functions, respectively.
   ir.Primitive buildConditional(
       ir.Primitive condition,
       ir.Primitive buildThenExpression(IrBuilder builder),
       ir.Primitive buildElseExpression(IrBuilder builder)) {
 
@@ skipping 1449 matching lines @@
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables) {
     assert(scope == null);
     // Move captured loop variables back into the local environment.
     // The update expression will use the values we put in the environment,
     // and then the environments for the initializer and update will be
     // joined at the head of the body.
     for (LocalElement loopVariable in loopVariables) {
       if (isInMutableVariable(loopVariable)) {
         ir.MutableVariable mutableVariable = getMutableVariable(loopVariable);
-        ir.Primitive get = new ir.GetMutableVariable(mutableVariable);
-        add(new ir.LetPrim(get));
-        environment.update(loopVariable, get);
+        ir.Primitive value =
+            addPrimitive(new ir.GetMutableVariable(mutableVariable));
+        environment.update(loopVariable, value);
         dartState.registerizedMutableVariables.add(loopVariable);
       }
     }
   }
 
   void _createFunctionParameter(ParameterElement parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isInMutableVariable(parameterElement)) {
       state.functionParameters.add(getMutableVariable(parameterElement));
@@ skipping 19 matching lines @@
   }
 
   /// Add [functionElement] to the environment with provided [definition].
   void declareLocalFunction(LocalFunctionElement functionElement,
                             ir.FunctionDefinition definition) {
     assert(isOpen);
     if (isInMutableVariable(functionElement)) {
       ir.MutableVariable variable = getMutableVariable(functionElement);
       add(new ir.DeclareFunction(variable, definition));
     } else {
-      ir.CreateFunction prim = new ir.CreateFunction(definition);
-      add(new ir.LetPrim(prim));
+      ir.CreateFunction prim = addPrimitive(new ir.CreateFunction(definition));
       environment.extend(functionElement, prim);
       prim.useElementAsHint(functionElement);
     }
   }
 
   /// Create a function expression from [definition].
   ir.Primitive buildFunctionExpression(ir.FunctionDefinition definition) {
-    ir.CreateFunction prim = new ir.CreateFunction(definition);
-    add(new ir.LetPrim(prim));
-    return prim;
+    return addPrimitive(new ir.CreateFunction(definition));
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     if (isInMutableVariable(local)) {
       // Do not use [local] as a hint on [result]. The variable should always
       // be inlined, but the hint prevents it.
-      ir.Primitive result =
-          new ir.GetMutableVariable(getMutableVariable(local));
-      add(new ir.LetPrim(result));
-      return result;
+      return addPrimitive(new ir.GetMutableVariable(getMutableVariable(local)));
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] with the provided [value].
   ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
     if (isInMutableVariable(local)) {
       add(new ir.SetMutableVariable(getMutableVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
-  ir.Primitive buildThis() {
-    ir.Primitive thisPrim = new ir.This();
-    add(new ir.LetPrim(thisPrim));
-    return thisPrim;
-  }
+  ir.Primitive buildThis() => addPrimitive(new ir.This());
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
     return _buildInvokeSuper(target, selector, arguments);
   }
 
 }
 
 /// State shared between JsIrBuilders within the same function.
@@ skipping 26 matching lines @@
   Map<ast.TryStatement, TryStatementInfo> get tryStatements => null;
   Set<Local> get mutableCapturedVariables => null;
   bool isInMutableVariable(Local local) => false;
   void makeMutableVariable(Local local) {}
   void removeMutableVariable(Local local) {}
 
   void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
-    ir.Primitive thisPrim = new ir.This();
-    add(new ir.LetPrim(thisPrim));
+    ir.Primitive thisPrim = addPrimitive(new ir.This());
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
         // Boxed variables are loaded from their box on-demand.
         jsState.boxedVariables[local] = location;
       } else {
         // Unboxed variables are loaded from the function object immediately.
         // This includes BoxLocals which are themselves unboxed variables.
-        ir.Primitive load = new ir.GetField(thisPrim, location.field);
-        add(new ir.LetPrim(load));
-        environment.extend(local, load);
+        environment.extend(local,
+            addPrimitive(new ir.GetField(thisPrim, location.field)));
       }
     });
 
     // If the function captures a reference to the receiver from the
     // enclosing method, remember which primitive refers to the receiver object.
     if (env.thisLocal != null && env.freeVariables.containsKey(env.thisLocal)) {
       jsState.receiver = environment.lookup(env.thisLocal);
     }
 
     // If the function has a self-reference, use the value of `this`.
     if (env.selfReference != null) {
       environment.extend(env.selfReference, thisPrim);
     }
   }
 
   /// Creates a box for [scope.box] and binds the captured variables to
   /// that box.
   ///
   /// The captured variables can subsequently be manipulated with
   /// [declareLocalVariable], [buildLocalGet], and [buildLocalSet].
   void enterScope(ClosureScope scope) => _enterScope(scope);
 
   void _enterScope(ClosureScope scope) {
     if (scope == null) return;
-    ir.CreateBox boxPrim = new ir.CreateBox();
-    add(new ir.LetPrim(boxPrim));
+    ir.CreateBox boxPrim = addPrimitive(new ir.CreateBox());
     environment.extend(scope.box, boxPrim);
     boxPrim.useElementAsHint(scope.box);
     scope.capturedVariables.forEach((Local local, ClosureLocation location) {
       assert(!jsState.boxedVariables.containsKey(local));
       if (location.isBox) {
         jsState.boxedVariables[local] = location;
       }
     });
   }
 
@@ skipping 38 matching lines @@
   ir.Primitive buildFunctionExpression(ClosureClassElement classElement) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     for (ClosureFieldElement field in classElement.closureFields) {
       // Captured 'this' is not available as a local in the current environment,
       // so treat that specially.
       ir.Primitive value = field.local is ThisLocal
           ? buildThis()
           : environment.lookup(field.local);
       arguments.add(value);
     }
-    ir.Primitive closure = new ir.CreateInstance(classElement, arguments);
-    add(new ir.LetPrim(closure));
-    return closure;
+    return addPrimitive(new ir.CreateInstance(classElement, arguments));
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(environment.lookup(location.box),
                                             location.field);
       result.useElementAsHint(local);
-      add(new ir.LetPrim(result));
-      return result;
+      return addPrimitive(result);
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] with the provided [value].
   ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
     ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
@@ skipping 25 matching lines @@
     _enterScope(scope);
   }
 
   void _enterForLoopUpdate(ClosureScope scope,
                            List<LocalElement> loopVariables) {
     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 = new ir.CreateBox();
+    ir.Primitive newBox = addPrimitive(new ir.CreateBox());
     newBox.useElementAsHint(scope.box);
-    add(new ir.LetPrim(newBox));
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
-      ir.Primitive get = new ir.GetField(box, location.field);
-      add(new ir.LetPrim(get));
-      add(new ir.SetField(newBox, location.field, get));
+      ir.Primitive value = addPrimitive(new ir.GetField(box, location.field));
+      add(new ir.SetField(newBox, location.field, value));
     }
     environment.update(scope.box, newBox);
   }
 
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
-    ir.Primitive thisPrim = new ir.This();
-    add(new ir.LetPrim(thisPrim));
-    return thisPrim;
+    return addPrimitive(new ir.This());
   }
 
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments) {
     // Direct calls to FieldElements are currently problematic because the
     // backend will not issue a getter for the field unless it finds a dynamic
     // access that matches its getter.
     // As a workaround, we generate GetField for this case, although ideally
     // this should be the result of inlining the field's getter.
     if (target is FieldElement) {
       if (selector.isGetter) {
-        ir.Primitive get = new ir.GetField(buildThis(), target);
-        add(new ir.LetPrim(get));
-        return get;
+        return addPrimitive(new ir.GetField(buildThis(), target));
       } else {
         assert(selector.isSetter);
         add(new ir.SetField(buildThis(), target, arguments.single));
         return arguments.single;
       }
     } else {
       return _buildInvokeSuper(target, selector, arguments);
     }
   }
 
@@ skipping 87 matching lines @@
 // TODO(johnniwinther): Support passing of [DartType] for the exception.
 class CatchClauseInfo {
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }