dart2dart: Method and constructor calls in new backend.

sdk/lib/_internal/compiler/implementation/ir/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 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../source_file.dart';
 import '../tree/tree.dart' as ast;
-import '../scanner/scannerlib.dart' show Token;
+import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import 'ir_pickler.dart' show Unpickler, IrConstantPool;
+import '../universe/universe.dart' show SelectorKind;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
  *
  * The functionality of the IrNodes is added gradually, therefore elements might
  * have an IR or not, depending on the language features that are used. For
  * elements that do have an IR, the tree [ast.Node]s and the [Token]s are not
  * used in the rest of the compilation. This is ensured by setting the element's
@@ skipping 470 matching lines @@
   }
 
 
   ir.Primitive visitLiteralNull(ast.LiteralNull node) {
     assert(isOpen);
     ir.Constant constant = new ir.Constant(constantSystem.createNull());
     add(new ir.LetPrim(constant));
     return constant;
   }
 
-  // TODO(kmillikin): other literals.  Strings require quoting and escaping
-  // in the Dart backend.
-  //   LiteralString
+  ir.Primitive visitLiteralString(ast.LiteralString node) {
+    assert(isOpen);
+    ir.Constant constant =
+        new ir.Constant(constantSystem.createString(node.dartString));
+    add(new ir.LetPrim(constant));
+    return constant;
+  }
+
+  // TODO(kmillikin): other literals.
   //   LiteralList
   //   LiteralMap
   //   LiteralMapEntry
   //   LiteralSymbol
 
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     assert(isOpen);
     return visit(node.expression);
   }
 
   // ==== Sends ====
   ir.Primitive visitAssert(ast.Send node) {
     assert(isOpen);
     return giveup();
   }
 
   ir.Primitive visitClosureSend(ast.Send node) {
     assert(isOpen);
     return giveup();
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
+    if (node.receiver == null || node.receiver.isSuper()) {
+      return giveup();
+    }
     assert(isOpen);

[Kevin Millikin (Google), 2014/05/09 10:21:22]

Move the assert up above the call to giveup.

-    return giveup();
+    Selector selector = elements.getSelector(node);
+    ir.Primitive receiver = visit(node.receiver);
+    List arguments = node.arguments.toList(growable:false)

[Kevin Millikin (Google), 2014/05/09 10:21:22]

This won't really handle optional/default arguments here.  In StaticSend, we use
selector.addArgumentsToList to giveup on them.

+                         .map(visit).toList(growable:false);
+    ir.Parameter v = new ir.Parameter(null);
+    ir.Continuation k = new ir.Continuation([v]);
+    ir.Expression invoke =
+        new ir.InvokeMethod(receiver, selector, k, arguments);
+    add(new ir.LetCont(k, invoke));
+    return v;
   }
 
   ir.Primitive visitGetterSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
-    if (!Elements.isLocal(element)) return giveup();
-    int index = variableIndex[element];
-    ir.Primitive value = assignedVars[index];
-    return value == null ? freeVars[index] : value;
+    if (Elements.isLocal(element)) {
+      int index = variableIndex[element];
+      ir.Primitive value = assignedVars[index];
+      return value == null ? freeVars[index] : value;
+    } else if (Elements.isInstanceField(element)) {
+      ir.Primitive receiver = visit(node.receiver);
+      ir.Parameter v = new ir.Parameter(null);
+      ir.Continuation k = new ir.Continuation([v]);
+      Selector selector = elements.getSelector(node);
+      assert(selector.kind == SelectorKind.GETTER);
+      ir.InvokeMethod invoke = new ir.InvokeMethod(receiver, selector, k, []);
+      add(new ir.LetCont(k, invoke));
+      return v;
+    } else {
+      // TODO(asgerf): static and top-level
+      // NOTE: Index-getters are OperatorSends, not GetterSends
+      return giveup();
+    }
   }
 
   ir.Primitive visitOperatorSend(ast.Send node) {
-    assert(isOpen);
-    return giveup();
+    ast.Operator selectorNode = node.selector;
+    if (!isUserDefinableOperator(selectorNode.source)) {
+      return giveup();
+    } else {
+      return visitDynamicSend(node);
+    }
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     // TODO(lry): support static fields. (separate IR instruction?)
     if (element.isField || element.isGetter) return giveup();
     // TODO(kmillikin): support static setters.
@@ skipping 38 matching lines @@
   }
 
   ir.Primitive visitTypeReferenceSend(ast.Send node) {
     assert(isOpen);
     return giveup();
   }
 
   ir.Primitive visitSendSet(ast.SendSet node) {
     assert(isOpen);
     Element element = elements[node];
-    if (!Elements.isLocal(element)) return giveup();
     if (node.assignmentOperator.source != '=') return giveup();
-    // Exactly one argument expected for a simple assignment.
-    assert(!node.arguments.isEmpty);
-    assert(node.arguments.tail.isEmpty);
-    ir.Primitive result = visit(node.arguments.head);
-    assignedVars[variableIndex[element]] = result;
-    return result;
+    if (Elements.isLocal(element)) {
+      // Exactly one argument expected for a simple assignment.
+      assert(!node.arguments.isEmpty);
+      assert(node.arguments.tail.isEmpty);
+      ir.Primitive result = visit(node.arguments.head);
+      assignedVars[variableIndex[element]] = result;
+      return result;
+    } else if (Elements.isStaticOrTopLevel(element)) {
+      // TODO(asgerf): static and top-level
+      return giveup();
+    } else if (Elements.isUnresolved(element)) {
+      return giveup();
+    } else {
+      // Setter or index-setter invocation
+      assert(node.receiver != null);
+      if (node.receiver.isSuper()) return giveup();
+
+      ir.Primitive receiver = visit(node.receiver);
+      ir.Parameter v = new ir.Parameter(null);
+      ir.Continuation k = new ir.Continuation([v]);
+      Selector selector = elements.getSelector(node);
+      assert(selector.kind == SelectorKind.SETTER ||
+             selector.kind == SelectorKind.INDEX);
+      List<ir.Definition> args = node.arguments.toList(growable:false)
+                                     .map(visit).toList(growable:false);
+      ir.InvokeMethod invoke = new ir.InvokeMethod(receiver, selector, k, args);
+      add(new ir.LetCont(k, invoke));
+      return v;

[Kevin Millikin (Google), 2014/05/09 10:21:22]

I actually think the better way to model this is that the value of the setter is
the value of the right-hand side and the result of the invoke is unused.

let prim v0 = ...receiver... in
let prim v1 = ...argument... in
let cont k v2 = ...continuation using v1 as result... in
  InvokeMethod(v0, selector, k, [v1])

One advantage is that anything we know about v1 we also know about the result of
the setter if used.  So here, return args.last instead of v?

+    }
+  }
+
+  ir.Primitive visitNewExpression(ast.NewExpression node) {
+    if (node.isConst) {
+      return giveup(); // TODO(asgerf): Const constructor call.
+    }
+    FunctionElement element = elements[node.send];
+    if (Elements.isUnresolved(element)) {
+      return giveup();
+    }
+    ast.Node selector = node.send.selector;
+    GenericType type = elements.getType(node);
+    ir.Parameter v = new ir.Parameter(null);
+    ir.Continuation k = new ir.Continuation([v]);
+    List<ir.Definition> args = node.send.arguments.toList(growable:false)

[Kevin Millikin (Google), 2014/05/09 10:21:22]

There can also be optional arguments here.

+                                        .map(visit).toList(growable:false);
+    ir.InvokeConstructor invoke = new ir.InvokeConstructor(
+        type,
+        element,
+        k,
+        args);
+    add(new ir.LetCont(k, invoke));
+    return v;
   }
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
   ir.Primitive giveup() => throw ABORT_IRNODE_BUILDER;
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e) {
@@ skipping 12 matching lines @@
   bool visit(DartType type, Null _) => type.accept(this, null);
 
   bool visitType(DartType type, Null _) => false;
 
   bool visitVoidType(VoidType type, Null _) => true;
 
   // Currently, InterfaceType and TypedefType are supported so long as they
   // do not have type parameters.  They are subclasses of GenericType.
   bool visitGenericType(GenericType type, Null _) => !type.isGeneric;
 }