dart2js: Simplification of the IrBuilderVisitor.

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 '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 191 matching lines @@
   /// Call [enterTry] before translating a try block and call this function
   /// after translating it.
   void leaveTry() {
     _boxedTryVariables.removeLast();
   }
 
   void _buildTryExit(IrBuilder builder) {
     for (Iterable<LocalVariableElement> boxedOnEntry in _boxedTryVariables) {
       for (LocalVariableElement variable in boxedOnEntry) {
         assert(builder.isInMutableVariable(variable));
-        ir.Primitive value = builder.buildLocalVariableGet(variable);
+        ir.Primitive value = builder.buildLocalGet(variable);
         builder.environment.update(variable, value);
       }
     }
   }
 
   /// True if a jump inserted now will escape from a try block.
   ///
   /// Concretely, this is true when [enterTry] has been called without
   /// its corresponding [leaveTry] call.
   bool get isEscapingTry => _boxedTryVariables.isNotEmpty;
@@ skipping 525 matching lines @@
   /// Creates a non-constant list literal of the provided [type] and with the
   /// provided [values].
   ir.Primitive buildListLiteral(InterfaceType type,
                                 Iterable<ir.Primitive> values,
                                 {TypeMask allocationSiteType}) {
     assert(isOpen);
     return addPrimitive(new ir.LiteralList(type, values.toList(),
         allocationSiteType: allocationSiteType));
   }
 
-  /// 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());
-    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)) {
     assert(isOpen);
 
     // The then and else expressions are delimited.
@@ skipping 190 matching lines @@
                                     TypeMask mask,
                                     ir.Primitive index,
                                     ir.Primitive value,
                                     {SourceInformation sourceInformation}) {
     _buildInvokeDynamic(
         receiver, new Selector.indexSet(), mask, <ir.Primitive>[index, value],
         sourceInformation);
     return value;
   }
 
-  /// Create a read access of the [local] variable or parameter.
-  ir.Primitive buildLocalVariableGet(LocalElement local) {
-    // TODO(johnniwinther): Separate function access from variable access.
-    return _buildLocalGet(local);
-  }
-
-  /// Create a read access of the local [function], i.e. closurization of
-  /// [function].
-  ir.Primitive buildLocalFunctionGet(LocalFunctionElement function) {
-    // TODO(johnniwinther): Separate function access from variable access.
-    return _buildLocalGet(function);
-  }
-
-  /// Create an invocation of the the [local] variable or parameter where
-  /// argument structure is defined by [callStructure] and the argument values
-  /// are defined by [arguments].
-  ir.Primitive buildLocalVariableInvocation(
-      LocalVariableElement local,
-      CallStructure callStructure,
-      List<ir.Primitive> arguments,
-      {SourceInformation callSourceInformation}) {
-    return buildCallInvocation(
-        buildLocalVariableGet(local), callStructure, arguments,
-        sourceInformation: callSourceInformation);
-  }
-
   /// Create an invocation of the local [function] where argument structure is
   /// defined by [callStructure] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildLocalFunctionInvocation(
       LocalFunctionElement function,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
       SourceInformation sourceInformation) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
-        buildLocalFunctionGet(function), callStructure, arguments,
+        buildLocalGet(function), callStructure, arguments,
         sourceInformation: sourceInformation);
   }
 
   /// Create a static invocation of [function].
   ///
   /// The arguments are not named and their values are defined by [arguments].
   ir.Primitive buildStaticFunctionInvocation(
       MethodElement function,
       List<ir.Primitive> arguments,
       {SourceInformation sourceInformation}) {
     Selector selector = new Selector.call(
         function.memberName, new CallStructure(arguments.length));
     return buildInvokeStatic(function, selector, arguments, sourceInformation);
   }
 
-  /// Create a read access of the static [field].
-  ir.Primitive buildStaticFieldGet(FieldElement field,
-                                   SourceInformation sourceInformation) {
-    return addPrimitive(new ir.GetStatic(field, sourceInformation));
-  }
-
-  /// Create a read access of a static [field] that might not have been
-  /// initialized yet.
-  ir.Primitive buildStaticFieldLazyGet(FieldElement field,
-                                       SourceInformation sourceInformation) {
-    return addPrimitive(new ir.GetLazyStatic(field, sourceInformation));
-  }
-
   /// Create a getter invocation of the static [getter].
   ir.Primitive buildStaticGetterGet(MethodElement getter,
                                     SourceInformation sourceInformation) {
     Selector selector = new Selector.getter(getter.memberName);
     return buildInvokeStatic(
         getter, selector, const <ir.Primitive>[], sourceInformation);
   }
 
-  /// Create a read access of the static [function], i.e. a closurization of
-  /// [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]) {
     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,
@@ skipping 360 matching lines @@
       List<ir.Primitive> value = <ir.Primitive>[currentValue];
       // Note the order of the comparisons below.  It can be the case that an
       // element isError and isMalformed.
       if (Elements.isError(variableElement)) {
         bodyBuilder.buildStaticNoSuchMethod(selector, value);
       } else {
         bodyBuilder.buildErroneousInvocation(variableElement, selector, value);
       }
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
       if (variableElement.isField) {
-        bodyBuilder.buildStaticFieldSet(variableElement, currentValue);
+        bodyBuilder.addPrimitive(
+            new ir.SetStatic(variableElement, currentValue));
       } else {
         bodyBuilder.buildStaticSetterSet(variableElement, currentValue);
       }
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       assert(receiver != null);
       bodyBuilder.buildDynamicSet(
           receiver, variableSelector, variableMask, currentValue);
     }
 
@@ skipping 293 matching lines @@
           ir.Expression body)) {
     JumpCollector join = new ForwardJumpCollector(environment);
     IrBuilder tryCatchBuilder = makeDelimitedBuilder();
 
     // Variables treated as mutable in a try are not mutable outside of it.
     // Work with a copy of the outer builder's mutable variables.
     tryCatchBuilder.mutableVariables =
         new Map<Local, ir.MutableVariable>.from(mutableVariables);
     for (LocalVariableElement variable in variables.boxedOnEntry) {
       assert(!tryCatchBuilder.isInMutableVariable(variable));
-      ir.Primitive value = tryCatchBuilder.buildLocalVariableGet(variable);
+      ir.Primitive value = tryCatchBuilder.buildLocalGet(variable);
       tryCatchBuilder.makeMutableVariable(variable);
       tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
     }
 
     IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
     enterTry(tryBuilder);
     buildTryBlock(tryBuilder);
     if (tryBuilder.isOpen) {
       join.enterTry(variables.boxedOnEntry);
       tryBuilder.jumpTo(join);
       join.leaveTry();
     }
     leaveTry(tryBuilder);
 
     IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
     for (LocalVariableElement variable in variables.boxedOnEntry) {
       assert(catchBuilder.isInMutableVariable(variable));
-      ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
+      ir.Primitive value = catchBuilder.buildLocalGet(variable);
       // After this point, the variables that were boxed on entry to the try
       // are no longer treated as mutable.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     List<ir.Parameter> catchParameters = buildCatch(catchBuilder, join);
     ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
     catchContinuation.body = catchBuilder._root;
     tryCatchBuilder.add(
@@ skipping 681 matching lines @@
         value = buildTypeVariableAccess(variable.typeVariable);
       } else {
         value = environment.lookup(field.local);
       }
       arguments.add(value);
     }
     return addPrimitive(new ir.CreateInstance(
         classElement, arguments, const <ir.Primitive>[], sourceInformation));
   }
 
-  /// Create a read access of [local] variable or parameter.
-  ir.Primitive _buildLocalGet(LocalElement local) {
+  /// Create a read access of [local] function, variable, or parameter.
+  ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     ClosureLocation location = state.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(environment.lookup(location.box),
                                             location.field);
       result.useElementAsHint(local);
       return addPrimitive(result);
     } else if (isInMutableVariable(local)) {
       return addPrimitive(new ir.GetMutable(getMutableVariable(local)));
     } else {
@@ skipping 405 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);
 }