Support local functions in analyzer2dart.

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_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 288 matching lines @@
 
   /// Add 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));
   }
 
   /// Add [variableElement] to the environment with [initialValue] as its
   /// initial value.
-  ///
-  /// [isClosureVariable] marks whether [variableElement] is accessed from an
-  /// inner function.
   void declareLocalVariable(LocalVariableElement variableElement,
                             {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       // TODO(kmillikin): Consider pooling constants.
       // The initial value is null.
       initialValue = buildNullLiteral();
     }
     if (isClosureVariable(variableElement)) {
       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);
     }
   }
 
+  /// Add [functionElement] to the environment with provided [definition].
+  void declareLocalFunction(LocalFunctionElement functionElement,
+                            ir.FunctionDefinition definition) {
+    assert(isOpen);
+    if (isClosureVariable(functionElement)) {
+      add(new ir.DeclareFunction(functionElement, definition));
+    } else {
+      ir.CreateFunction prim = new ir.CreateFunction(definition);
+      add(new ir.LetPrim(prim));
+      environment.extend(functionElement, prim);
+      prim.useElementAsHint(functionElement);
+    }
+  }
+
   // 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 25 matching lines @@
   }
 
   ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
                                    Selector selector,
                                    List<ir.Definition> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethod(receiver, selector, k, arguments));
   }
 
+  ir.Primitive _buildInvokeCall(ir.Primitive target,
+                                 Selector selector,
+                                 List<ir.Definition> arguments) {
+    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;
   }
 
   // Helper for building primitive literals.
@@ skipping 100 matching lines @@
                 new ir.LetCont(elseContinuation,
                     new ir.Branch(new ir.IsTrue(condition),
                                   thenContinuation,
                                   elseContinuation)))));
     return (thenValue == elseValue)
         ? thenValue
         : joinContinuation.parameters.last;
 
   }
 
+  /// 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;
+  }
+
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullLiteral();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
@@ skipping 15 matching lines @@
       assert(invariant(element, _root == null,
           message: "Non-empty body for abstract method $element: $_root"));
       assert(invariant(element, state.localConstants.isEmpty,
           message: "Local constants for abstract method $element: "
                    "${state.localConstants}"));
       return new ir.FunctionDefinition.abstract(
                 element, _parameters, defaults);
     }
   }
 
-
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Selector selector,
                                     List<ir.Definition> arguments) {
     return _buildInvokeSuper(selector, arguments);
   }
 
   /// Create a getter invocation on the super class where the getter name is
   /// defined by [selector].
@@ skipping 115 matching lines @@
     assert(isOpen);
     if (isClosureVariable(local)) {
       add(new ir.SetClosureVariable(local, value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
+  /// Create an invocation of [local] where the argument structure is defined
+  /// by [selector] and the argument values are defined by [arguments].
+  ir.Primitive buildLocalInvocation(LocalElement local,
+                                    Selector selector,
+                                    List<ir.Definition> arguments) {
+    ir.Primitive receiver;
+    if (isClosureVariable(local)) {
+      receiver = new ir.GetClosureVariable(local);
+      add(new ir.LetPrim(receiver));
+    } else {
+      receiver = environment.lookup(local);
+    }
+    return _buildInvokeCall(receiver, selector, arguments);
+  }
+
+  /// Create an invocation of the [functionExpression] where the argument
+  /// structure are defined by [selector] and the argument values are defined by
+  /// [arguments].
+  ir.Primitive buildFunctionExpressionInvocation(
+      ir.Primitive functionExpression,
+      Selector selector,
+      List<ir.Definition> arguments) {
+    return _buildInvokeCall(functionExpression, selector, arguments);
+  }
+
   /// Creates an if-then-else statement with the provided [condition] where the
   /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   // TODO(johnniwinther): Unify implementation with [buildConditional] and
   // [_buildLogicalOperator].
   void buildIf(ir.Primitive condition,
                void buildThenPart(IrBuilder builder),
                void buildElsePart(IrBuilder builder)) {
@@ skipping 725 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }