dart2dart: Method and constructor calls in new backend.

sdk/lib/_internal/compiler/implementation/dart_backend/tree_tracer.dart

 library dart_backend.tracer;
 
 import 'dart:async' show EventSink;
 import '../tracer.dart';
 import 'dart_tree.dart';
 
 class Block {
   int index;
   final List<Statement> statements = <Statement>[];
   final List<Block> predecessors = <Block>[];
@@ skipping 25 matching lines @@
     block.index = blocks.length;
     blocks.add(block);
   }
 
   void collect(FunctionDefinition function) {
     visitStatement(function.body);
   }
 
   visitVariable(Variable node) {}
   visitInvokeStatic(InvokeStatic node) {}
+  visitInvokeMethod(InvokeMethod node) {}
+  visitInvokeConstructor(InvokeConstructor node) {}
   visitConstant(Constant node) {}
 
   visitLabeledStatement(LabeledStatement node) {
     Block target = new Block();
     breakTargets[node.label] = target;
     visitStatement(node.body);
     _addBlock(target);
     visitStatement(node.next);
   }
 
@@ skipping 98 matching lines @@
 
   visitLabeledStatement(LabeledStatement node) {
     // These do not get added to a block's list of statements.
   }
 
   visitAssign(Assign node) {
     String name = names.varName(node.variable);
     String rhs = expr(node.definition);
     printStatement(name, "let $name = $rhs");
   }
+  
+  visitInvokeMethod(InvokeMethod node) {
+    printStatement(null, expr(node));
+  }
+  
+  visitInvokeConstructor(InvokeConstructor node) {
+    printStatement(null, expr(node));
+  }
 
   visitReturn(Return node) {
     printStatement(null, "return ${expr(node.value)}");
   }
 
   visitBreak(Break node) {
     printStatement(null, "break ${collector.breakTargets[node.target].name}");
   }
 
   visitIf(If node) {
@@ skipping 19 matching lines @@
 
   String visitVariable(Variable node) {
     return names.varName(node);
   }
 
   String visitInvokeStatic(InvokeStatic node) {
     String head = node.target.name;
     String args = node.arguments.map((e) => e.accept(this)).join(', ');
     return "$head($args)";
   }
+  
+  String visitInvokeMethod(InvokeMethod node) {
+    String receiver = node.receiver.accept(this);
+    String name = node.selector.name;
+    String args = node.arguments.map((e) => e.accept(this)).join(', ');
+    return "$receiver.$name($args)";
+  }
+  
+  String visitInvokeConstructor(InvokeConstructor node) {
+    String callName;
+    if (node.target.name.isEmpty) {
+      callName = '${node.type}';
+    } else {
+      callName = '${node.type}.${node.target.name}';
+    }
+    String args = node.arguments.map(visitExpression).join(', ');
+    return "new $callName($args)";
+  }
 
   String visitConstant(Constant node) {
     return "${node.value}";
   }
 
   // Note: There should not be statements in the context of expressions.
   String visitStatement(Statement node) {
     return "${node.runtimeType} statement in expression context";
   }
 
@@ skipping 28 matching lines @@
       }
       while (name == null || _usedNames.contains(name)) {
         name = "v${_counter++}";
       }
       _names[v] = name;
       _usedNames.add(name);
     }
     return name;
   }
 }