dart2js: Eliminate the JsIrBuilderVisitor.

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' hide ClosureScope;
+import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
     Selectors;
 import '../compile_time_constants.dart' show
     BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/values.dart' show
     ConstantValue,
     PrimitiveConstantValue;
@@ skipping 2442 matching lines @@
           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,
+                            closure.ClosureClassElement classElement,
                             SourceInformation sourceInformation) {
     ir.Primitive closure =
          buildFunctionExpression(classElement, sourceInformation);
     declareLocalVariable(functionElement, initialValue: closure);
   }
 
-  ir.Primitive buildFunctionExpression(ClosureClassElement classElement,
+  ir.Primitive buildFunctionExpression(closure.ClosureClassElement classElement,
                                        SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
-    for (ClosureFieldElement field in classElement.closureFields) {
+    for (closure.ClosureFieldElement field in classElement.closureFields) {
       // Captured 'this' and type variables are not always available as locals
       // in the environment, so treat those specially.
       ir.Primitive value;
-      if (field.local is ThisLocal) {
+      if (field.local is closure.ThisLocal) {
         value = buildThis();
-      } else if (field.local is TypeVariableLocal) {
-        TypeVariableLocal variable = field.local;
+      } else if (field.local is closure.TypeVariableLocal) {
+        closure.TypeVariableLocal variable = field.local;
         value = buildTypeVariableAccess(variable.typeVariable);
       } else {
         value = environment.lookup(field.local);
       }
       arguments.add(value);
     }
     return addPrimitive(new ir.CreateInstance(
         classElement, arguments, const <ir.Primitive>[], sourceInformation));
   }
 
@@ skipping 184 matching lines @@
   ///
   /// The value of [variable] is taken from the current receiver object, or
   /// if we are currently building a constructor field initializer, from the
   /// corresponding type argument (field initializers are evaluated before the
   /// receiver object is created).
   ir.Primitive buildTypeVariableAccess(TypeVariableType variable,
                                        {SourceInformation sourceInformation}) {
     // If the local exists in the environment, use that.
     // This is put here when we are inside a constructor or field initializer,
     // (or possibly a closure inside one of these).
-    Local local = new TypeVariableLocal(variable, state.currentElement);
+    Local local = new closure.TypeVariableLocal(variable, state.currentElement);
     if (environment.contains(local)) {
       return environment.lookup(local);
     }
 
     // If the type variable is not in a local, read its value from the
     // receiver object.
     ir.Primitive target = buildThis();
     return addPrimitive(
         new ir.ReadTypeVariable(variable, target, sourceInformation));
   }
 
   /// Make the given type variable accessible through the local environment
   /// with the value of [binding].
   void declareTypeVariable(TypeVariableType variable, DartType binding) {
     environment.extend(
-        new TypeVariableLocal(variable, state.currentElement),
+        new closure.TypeVariableLocal(variable, state.currentElement),
         buildTypeExpression(binding));
   }
 
   /// Reifies the value of [variable] on the current receiver object.
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable,
                                       SourceInformation sourceInformation) {
     ir.Primitive typeArgument =
         buildTypeVariableAccess(variable, sourceInformation: sourceInformation);
     return addPrimitive(
         new ir.ReifyRuntimeType(typeArgument, sourceInformation));
@@ skipping 126 matching lines @@
     return addPrimitive(new ir.Refinement(value, type));
   }
 }
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
-  final BoxLocal box;
+  final closure.BoxLocal box;
 
   /// The field in which the variable is stored.
   final Entity field;
 
   bool get isBox => box != null;
 
   ClosureLocation(this.box, this.field);
+
+  /// Converts a map containing closure.dart's [CapturedVariable]s into one
+  /// containing [ClosureLocation]s.
+  ///
+  /// There is a 1:1 corresponce between these; we do this because the
+  /// IR builder should not depend on synthetic elements.
+  static Map<Local, ClosureLocation> mapFrom(
+      Map<Local, closure.CapturedVariable> map) {
+    Map result = {};
+    map.forEach((Local k, closure.CapturedVariable v) {
+      closure.BoxLocal box = v is closure.BoxFieldElement ? v.box : null;
+      result[k] = new ClosureLocation(box, v);
+    });
+    return result;
+  }
 }
 
 /// Introduces a new box and binds local variables to this box.
 ///
 /// A [ClosureScope] may exist for each function and for each loop.
 /// Generally, one may pass `null` to the [IrBuilder] instead of a
 /// [ClosureScope] when a given scope has no boxed variables.
 class ClosureScope {
   /// This box is now in scope and [capturedVariables] may use it.
-  final BoxLocal box;
+  final closure.BoxLocal box;
 
   /// Maps [LocalElement]s to their location.
   final Map<Local, ClosureLocation> capturedVariables;
 
   /// If this is the scope of a for-loop, [boxedLoopVariables] is the list
   /// of boxed variables that are declared in the initializer.
   final List<VariableElement> boxedLoopVariables;
 
-  ClosureScope(this.box, this.capturedVariables, this.boxedLoopVariables);
+  factory ClosureScope(closure.ClosureScope scope) {
+    return scope == null ? null : new ClosureScope._internal(scope);
+  }
+
+  ClosureScope._internal(closure.ClosureScope scope)
+      : box = scope.boxElement,
+        capturedVariables = ClosureLocation.mapFrom(scope.capturedVariables),
+        boxedLoopVariables = scope.boxedLoopVariables;
 }
 
 /// Environment passed when building a nested function, describing how
 /// to access variables from the enclosing scope.
 class ClosureEnvironment {
   /// References to this local should be treated as recursive self-reference.
   /// (This is *not* in [freeVariables]).
   final LocalFunctionElement selfReference;
 
   /// If non-null, [thisLocal] has an entry in [freeVariables] describing where
   /// to find the captured value of `this`.
-  final ThisLocal thisLocal;
+  final closure.ThisLocal thisLocal;
 
   /// Maps [LocalElement]s, [BoxLocal]s and [ThisLocal] to their location.
   final Map<Local, ClosureLocation> freeVariables;
 
-  ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
+  factory ClosureEnvironment(closure.ClosureClassMap closureClassMap) {
+    if (closureClassMap.closureElement == null) return null;
+    return new ClosureEnvironment._internal(closureClassMap);
+  }
+
+  ClosureEnvironment._internal(closure.ClosureClassMap closureClassMap)
+      : selfReference = closureClassMap.closureElement,
+        thisLocal = closureClassMap.thisLocal,
+        freeVariables =
+            ClosureLocation.mapFrom(closureClassMap.freeVariableMap);
 }
 
 class TryStatementInfo {
   final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
   final Set<LocalVariableElement> boxedOnEntry =
       new Set<LocalVariableElement>();
 }
 
 class CatchClauseInfo {
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }