Support local variables in analyzer2dart.

sdk/lib/_internal/compiler/implementation/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_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 147 matching lines @@
     // TODO(kmillikin): This is still kind of fishy.  Refactor to not share
     // name maps or else garbage collect unneeded names.
     assert(element == null || !variable2index.containsKey(element));
     variable2index[element] = index2variable.length;
     index2variable.add(element);
     index2value.add(value);
   }
 
   ir.Primitive lookup(Element element) {
     assert(!element.isConst);
+    assert(invariant(element, variable2index.containsKey(element),
+        message: "Unknown variable: $element."));

[floitsch, 2014/10/16 12:23:59]

I would indent message to the invariant-args. But ok with how it is.

[Johnni Winther, 2014/10/16 13:01:26]

Done.

     return index2value[variable2index[element]];
   }
 
   void update(Element element, ir.Primitive value) {
     index2value[variable2index[element]] = value;
   }
 
   /// Verify that the variable2index and index2variable maps agree up to the
   /// index [length] exclusive.
   bool sameDomain(int length, Environment other) {
@@ skipping 52 matching lines @@
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
   ConstantSystem constantSystem = DART_CONSTANT_SYSTEM;
 
   ir.Continuation returnContinuation = new ir.Continuation.retrn();
 
   List<ir.Parameter> _parameters = <ir.Parameter>[];
 
   /// A map from variable indexes to their values.
   Environment environment = new Environment.empty();
 
+  List<ConstDeclaration> _localConstants = <ConstDeclaration>[];
+
   // The IR builder maintains a context, which is an expression with a hole in
   // it.  The hole represents the focus where new expressions can be added.
   // The context is implemented by 'root' which is the root of the expression
   // and 'current' which is the expression that immediately contains the hole.
   // Not all expressions have a hole (e.g., invocations, which always occur in
   // tail position, do not have a hole).  Expressions with a hole have a plug
   // method.
   //
   // Conceptually, visiting a statement takes a context as input and returns
   // either a new context or else an expression without a hole if all
@@ skipping 23 matching lines @@
                        {bool isClosureVariable: false}) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     if (isClosureVariable) {
       add(new ir.SetClosureVariable(parameterElement, parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
+  void declareLocalConstant(LocalVariableElement variableElement,
+                            ConstantExpression value) {
+    _localConstants.add(new ConstDeclaration(variableElement, value));
+  }
+
+  void declareLocalVariable(LocalVariableElement variableElement,
+                            {ir.Primitive initialValue,
+                             bool isClosureVariable: false}) {
+    assert(isOpen);
+    if (initialValue == null) {
+      // TODO(kmillikin): Consider pooling constants.
+      // The initial value is null.
+      initialValue = makePrimConst(constantSystem.createNull());
+      add(new ir.LetPrim(initialValue));
+    }
+    if (isClosureVariable) {
+      add(new ir.SetClosureVariable(variableElement,
+                                    initialValue,
+                                    isDeclaration: true));
+    } else {
+      // In case a primitive was introduced for the initializer expression,
+      // use this variable element to help derive a good name for it.
+      initialValue.useElementAsHint(variableElement);
+      environment.extend(variableElement, initialValue);
+    }
+  }
+
   // 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 {
@@ skipping 78 matching lines @@
     add(new ir.InvokeContinuation(returnContinuation, [constant]));
     _current = null;
   }
 
   /// Create a [ir.FunctionDefinition] for [element] using [_root] as the body.
   ///
   /// Parameters must be created before the construction of the body using
   /// [createParameter].
   ir.FunctionDefinition buildFunctionDefinition(
       FunctionElement element,
-      List<ConstDeclaration> constants,
       List<ConstantExpression> defaults) {
     if (!element.isAbstract) {
       ensureReturn();
       return new ir.FunctionDefinition(
-          element, returnContinuation, _parameters, _root, constants, defaults);
+          element, returnContinuation, _parameters, _root,
+          _localConstants, defaults);
     } else {
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
-      assert(invariant(element, constants.isEmpty,
-          message: "Local constants for abstract method $element: $constants"));
+      assert(invariant(element, _localConstants.isEmpty,
+          message: "Local constants for abstract method $element: "
+                   "$_localConstants"));
       return new ir.FunctionDefinition.abstract(
                 element, _parameters, defaults);
     }
   }
 
   /// Create a static invocation of [element] with arguments structure defined
   /// by [selector] and argument values defined by [arguments].
   ir.Primitive buildStaticInvocation(Element element,
                                      Selector selector,
                                      List<ir.Definition> arguments) {
@@ skipping 44 matching lines @@
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors;
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors;
 
-  final List<ConstDeclaration> localConstants;
-
   FunctionElement currentFunction;
   final DetectClosureVariables closureLocals;
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
       : breakCollectors = <JumpCollector>[],
         continueCollectors = <JumpCollector>[],
-        localConstants = <ConstDeclaration>[],
         closureLocals = new DetectClosureVariables(elements),
         super(elements) {
     constantSystem = compiler.backend.constantSystem;
   }
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// The delimited visitor has its own compile-time environment mapping
   /// local variables to their values, which is initially a copy of the parent
   /// environment.  It has its own context for building an IR expression, so
   /// the built expression is not plugged into the parent's context.
   IrBuilderVisitor.delimited(IrBuilderVisitor parent)
       : compiler = parent.compiler,
         sourceFile = parent.sourceFile,
         breakCollectors = parent.breakCollectors,
         continueCollectors = parent.continueCollectors,
-        localConstants = parent.localConstants,
         currentFunction = parent.currentFunction,
         closureLocals = parent.closureLocals,
         super(parent.elements) {
     constantSystem = parent.constantSystem;
     returnContinuation = parent.returnContinuation;
+    _localConstants = parent._localConstants;
     environment = new Environment.from(parent.environment);
   }
 
   /// Construct a visitor for a recursive continuation.
   ///
   /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
   /// for all the local variables in the parent, because the invocation sites
   /// of the continuation are not all known when the builder is created.  The
   /// recursive invocations will be passed values for all the local variables,
   /// which may be eliminated later if they are redundant---if they take on
   /// the same value at all invocation sites.
   IrBuilderVisitor.recursive(IrBuilderVisitor parent)
       : compiler = parent.compiler,
         sourceFile = parent.sourceFile,
         breakCollectors = parent.breakCollectors,
         continueCollectors = parent.continueCollectors,
-        localConstants = parent.localConstants,
         currentFunction = parent.currentFunction,
         closureLocals = parent.closureLocals,
         super(parent.elements) {
     constantSystem = parent.constantSystem;
     returnContinuation = parent.returnContinuation;
+    _localConstants = parent._localConstants;
     parent.environment.index2variable.forEach(createParameter);
   }
 
   /**
    * Builds the [ir.FunctionDefinition] for a function element. In case the
    * function uses features that cannot be expressed in the IR, this function
    * returns `null`.
    */
   ir.FunctionDefinition buildFunction(FunctionElement functionElement) {
     return nullIfGiveup(() => buildFunctionInternal(functionElement));
@@ skipping 16 matching lines @@
       createParameter(parameterElement,
                       isClosureVariable: isClosureVariable(parameterElement));
     });
 
     List<ConstantExpression> defaults = new List<ConstantExpression>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
     visit(function.body);
-    return buildFunctionDefinition(element, localConstants, defaults);
+    return buildFunctionDefinition(element, defaults);
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   // Build(Block(stamements), C) = C'
   //   where C' = statements.fold(Build, C)
   ir.Primitive visitBlock(ast.Block node) {
     assert(isOpen);
     for (ast.Node n in node.statements.nodes) {
@@ skipping 577 matching lines @@
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
         ConstantExpression value = getConstantForVariable(element);
-        localConstants.add(new ConstDeclaration(element, value));
+        declareLocalConstant(element, value);
       }
     } else {
       for (ast.Node definition in node.definitions.nodes) {
         Element element = elements[definition];
         ir.Primitive initialValue;
         // Definitions are either SendSets if there is an initializer, or
         // Identifiers if there is no initializer.
         if (definition is ast.SendSet) {
           assert(!definition.arguments.isEmpty);
           assert(definition.arguments.tail.isEmpty);
           initialValue = visit(definition.arguments.head);
         } else {
           assert(definition is ast.Identifier);
-          // The initial value is null.
-          // TODO(kmillikin): Consider pooling constants.
-          initialValue = makePrimConst(constantSystem.createNull());
-          add(new ir.LetPrim(initialValue));
         }
-        if (isClosureVariable(element)) {
-          LocalElement local = element;
-          add(new ir.SetClosureVariable(local, initialValue,
-                                        isDeclaration: true));
-        } else {
-          // In case a primitive was introduced for the initializer expression,
-          // use this variable element to help derive a good name for it.
-          initialValue.useElementAsHint(element);
-          environment.extend(element, initialValue);
-        }
+        declareLocalVariable(element,
+                             initialValue: initialValue,
+                             isClosureVariable: isClosureVariable(element));
       }
     }
     return null;
   }
 
   // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
@@ skipping 770 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }