Support dynamic get/invocation 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 327 matching lines @@
   IrBuilder.recursive(IrBuilder parent)
       : this.state = parent.state,
         this.environment = new Environment.empty() {
     parent.environment.index2variable.forEach(createParameter);
   }
 
 
   bool get isOpen => _root == null || _current != null;
 
   /// Create a parameter for [parameterElement] and add it to the current
-  /// environment. If [isClosureVariable] marks whether [parameterElement] is
-  /// accessed from an inner function.
+  /// environment.
+  ///
+  /// [isClosureVariable] marks whether [parameterElement] is accessed from an
+  /// inner function.
   void createParameter(LocalElement parameterElement,
                        {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);
     }
   }
 
+  /// 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,
                              bool isClosureVariable: false}) {
     assert(isOpen);
     if (initialValue == null) {
       // TODO(kmillikin): Consider pooling constants.
       // The initial value is null.
       initialValue = makePrimConst(state.constantSystem.createNull());
       add(new ir.LetPrim(initialValue));
     }
@@ skipping 68 matching lines @@
     return buildPrimConst(state.constantSystem.createNull());
   }
 
   /// Create a string literal.
   ir.Constant buildStringLiteral(String value) {
     return buildPrimConst(
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a get access of [local].
-  ir.Primitive buildGetLocal(Element local) {
+  ir.Primitive buildLocalGet(Element local) {
     assert(isOpen);
     return environment.lookup(local);
   }
 
   /// Create a get access of the static [element].
-  ir.Primitive buildGetStatic(Element element, Selector selector) {
+  ir.Primitive buildStaticGet(Element element, Selector selector) {
     assert(isOpen);
     assert(selector.isGetter);
     return continueWithExpression(
-        (k) => new ir.InvokeStatic(element, selector, k, []));
+        (k) => new ir.InvokeStatic(
+            element, selector, k, const <ir.Definition>[]));
+  }
+
+  /// Create a dynamic get access on [receiver] where the property is defined
+  /// by the getter [selector].
+  ir.Primitive buildDynamicGet(ir.Primitive receiver, Selector selector) {
+    assert(isOpen);
+    assert(selector.isGetter);
+    return continueWithExpression(
+        (k) => new ir.InvokeMethod(
+            receiver, selector, k, const <ir.Definition>[]));
   }
 
   /**
    * 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 = makePrimConst(state.constantSystem.createNull());
@@ skipping 18 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 with method name and arguments structure defined
+  /// by [selector] and argument values defined by [arguments].
+  ir.Primitive buildSuperInvocation(Selector selector,
+                                    List<ir.Definition> arguments) {
+    assert(isOpen);
+    return continueWithExpression(
+        (k) => new ir.InvokeSuperMethod(selector, k, arguments));
+
+  }
+
+  /// Create a dynamic invocation on [receiver] with method name and arguments
+  /// structure defined by [selector] and argument values defined by
+  /// [arguments].
+  ir.Primitive buildDynamicInvocation(ir.Definition receiver,
+                                      Selector selector,
+                                      List<ir.Definition> arguments) {
+    assert(isOpen);
+    return continueWithExpression(
+        (k) => new ir.InvokeMethod(receiver, selector, k, arguments));
+  }
+
   /// 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) {
     return continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
@@ skipping 965 matching lines @@
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
     assert(irBuilder.isOpen);
     Selector selector = elements.getSelector(node);
     ir.Primitive receiver = visitReceiver(node.receiver);
     List<ir.Primitive> arguments = new List<ir.Primitive>();
     for (ast.Node n in node.arguments) {
       arguments.add(visit(n));
     }
-    return irBuilder.continueWithExpression(
-        (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
+    return irBuilder.buildDynamicInvocation(receiver, selector, arguments);
   }
 
   _GetterElements translateGetter(ast.Send node, Selector selector) {
     Element element = elements[node];
     ir.Primitive result;
     ir.Primitive receiver;
     ir.Primitive index;
 
     if (element != null && element.isConst) {
       // Reference to constant local, top-level or static field
       result = translateConstant(node);
     } else if (isClosureVariable(element)) {
       LocalElement local = element;
       result = new ir.GetClosureVariable(local);
       irBuilder.add(new ir.LetPrim(result));
     } else if (Elements.isLocal(element)) {
       // Reference to local variable
-      result = irBuilder.buildGetLocal(element);
+      result = irBuilder.buildLocalGet(element);
     } else if (element == null ||
                Elements.isInstanceField(element) ||
                Elements.isInstanceMethod(element) ||
                selector.isIndex ||
                // TODO(johnniwinther): clean up semantics of resolution.
                node.isSuperCall) {
       // Dynamic dispatch to a getter. Sometimes resolution will suggest a
       // target element, but in these cases we must still emit a dynamic
       // dispatch. The target element may be an instance method in case we are
       // converting a method to a function object.
@@ skipping 10 matching lines @@
       result = irBuilder.continueWithExpression(
           (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
     } else if (element.isField || element.isGetter || element.isErroneous ||
                element.isSetter) {
       // TODO(johnniwinther): Change handling of setter selectors.
       // Access to a static field or getter (non-static case handled above).
       // Even if there is only a setter, we compile as if it was a getter,
       // so the vm can fail at runtime.
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.SETTER);
-      result = irBuilder.buildGetStatic(element, selector);
+      result = irBuilder.buildStaticGet(element, selector);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // Convert a top-level or static function to a function object.
       result = translateConstant(node);
     } else {
       throw "Unexpected SendSet getter: $node, $element";
     }
     return new _GetterElements(
         result: result,index: index, receiver: receiver);
   }
 
@@ skipping 172 matching lines @@
                                                              growable:false);
     return irBuilder.buildStaticInvocation(element, selector, arguments);
   }
 
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(irBuilder.isOpen);
     if (node.isPropertyAccess) {
       return visitGetterSend(node);
     } else {
-      return visitDynamicSend(node);
+      Selector selector = elements.getSelector(node);
+      List<ir.Primitive> arguments = new List<ir.Primitive>();

[floitsch, 2014/10/17 11:34:48]

= node.arguments.mapToList(visit, growable: false) ?

[Johnni Winther, 2014/10/17 11:54:30]

Done.

+      for (ast.Node n in node.arguments) {
+        arguments.add(visit(n));
+      }
+      return irBuilder.buildSuperInvocation(selector, arguments);
     }
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   ir.Primitive visitTypeLiteralSend(ast.Send node) {
     assert(irBuilder.isOpen);
     // If the user is trying to invoke the type literal or variable,
@@ skipping 280 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }