dart2dart: Method and constructor calls in new backend.

sdk/lib/_internal/compiler/implementation/ir/ir_pickler.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_pickler;
 
 import 'ir_nodes.dart' as ir;
 import '../dart2jslib.dart' show
     Constant, FalseConstant, TrueConstant, IntConstant, DoubleConstant,
     StringConstant, NullConstant, ListConstant, MapConstant,
     InterceptorConstant, DummyConstant, FunctionConstant, TypeConstant,
     ConstructedConstant,
     ConstantVisitor, ConstantSystem,
     Compiler, NO_LOCATION_SPANNABLE;
 import 'dart:typed_data' show ByteData, Endianness, Uint8List;
 import 'dart:convert' show UTF8;
 import '../tree/tree.dart' as ast show
     DartString, LiteralDartString, RawSourceDartString, EscapedSourceDartString,
     ConsDartString;
 import '../elements/elements.dart' show
     Element, LibraryElement, FunctionElement;
 import '../universe/universe.dart' show Selector, TypedSelector, SelectorKind;
+import '../dart_types.dart' as types;
 
 part 'ir_unpickler.dart';
 
 /* The int(entries) counts expression nodes, which might potentially be
  * referred to in a back reference.
  *
  * pickle   ::= int(entries) function
  *
  * function ::= int(parameter count) {element(parameter)} node(body)
  *
  * int      ::= see [writeInt] for number encoding
  *
  * string   ::= byte(STRING_ASCII) int(length) {byte(ascii)}
  *            | byte(STRING_UTF8) int(length) {byte(utf8)}
  *
  * node      ::= byte(NODE_CONSTANT) constant node(next)
  *             | byte(NODE_LET_CONT) int(parameter count) node(next) node(body)
  *             | byte(NODE_INVOKE_STATIC) element selector
  *                   reference(continuation) {reference(argument)}
+ *             | byte(NODE_INVOKE_METHOD) reference(receiver) selector
+ *                   reference(continuation) {reference(argument)}
+ *             | byte(NODE_INVOKE_CONSTRUCTOR) type element(target) 
+ *                   reference(continuation) {reference(argument)}
  *             | byte(NODE_INVOKE_CONTINUATION) reference(continuation)
  *                   {reference(argument)}
  *
  * reference ::= int(indexDelta)
  *
  * constant   ::= byte(CONST_BOOL) byte(0 or 1)
  *              | byte(CONST_DOUBLE) byte{8}
  *              | byte(CONST_INT) int(value)
  *              | byte(CONST_STRING_LITERAL) string
  *              | byte(CONST_STRING_RAW) string int(length)
  *              | byte(CONST_STRING_ESCAPED) string int(length)
  *              | byte(CONST_STRING_CONS) constant(left) constant(right)
  *              | byte(CONST_NULL)
  *
  * selector   ::= byte(BACKREFERENCE) reference
  *              | byte(SELECTOR_UNTYPED) int(kind) string(name) element(library)
  *                    int(argumentsCount) int(namedArgumentsCount)
  *                    {string(parameterName)}
  *
  * element    ::= int(constantPoolIndex)
+ * 
+ * type       ::= int(constantPoolIndex)
  */
 class Pickles {
   static const int BACKREFERENCE = 1;
 
   static const int STRING_ASCII = BACKREFERENCE + 1;
   static const int STRING_UTF8  = STRING_ASCII + 1;
 
   static const int FIRST_NODE_TAG           = STRING_UTF8 + 1;
   static const int NODE_CONSTANT            = FIRST_NODE_TAG;
   static const int NODE_IS_TRUE             = NODE_CONSTANT + 1;
   static const int NODE_LET_CONT            = NODE_IS_TRUE + 1;
   static const int NODE_INVOKE_STATIC       = NODE_LET_CONT + 1;
-  static const int NODE_INVOKE_CONTINUATION = NODE_INVOKE_STATIC + 1;
+  static const int NODE_INVOKE_METHOD       = NODE_INVOKE_STATIC + 1;
+  static const int NODE_INVOKE_CONSTRUCTOR  = NODE_INVOKE_METHOD + 1;
+  static const int NODE_INVOKE_CONTINUATION = NODE_INVOKE_CONSTRUCTOR + 1;
   static const int NODE_BRANCH              = NODE_INVOKE_CONTINUATION + 1;
   static const int LAST_NODE_TAG            = NODE_BRANCH;
 
   static const int FIRST_CONST_TAG      = LAST_NODE_TAG + 1;
   static const int CONST_BOOL           = FIRST_CONST_TAG;
   static const int CONST_INT            = CONST_BOOL + 1;
   static const int CONST_DOUBLE         = CONST_INT + 1;
   static const int CONST_STRING_LITERAL = CONST_DOUBLE + 1;
   static const int CONST_STRING_RAW     = CONST_STRING_LITERAL + 1;
   static const int CONST_STRING_ESCAPED = CONST_STRING_RAW + 1;
@@ skipping 245 matching lines @@
     }
   }
 
   void writeConstNull() {
     writeByte(Pickles.CONST_NULL);
   }
 
   void writeElement(Element element) {
     writeInt(constantPool.add(element));
   }
+  
+  void writeDartType(types.DartType type) {
+    writeInt(constantPool.add(type));
+  }
 
   void writeSelector(Selector selector) {
     if (emitted.containsKey(selector)) {
       writeByte(Pickles.BACKREFERENCE);
       writeBackReference(selector);
     } else {
       recordForBackReference(selector);
       assert(selector is !TypedSelector);
       writeByte(Pickles.SELECTOR_UNTYPED);
       writeInt(selector.kind.hashCode);
@@ skipping 45 matching lines @@
   void visitInvokeStatic(ir.InvokeStatic node) {
     writeByte(Pickles.NODE_INVOKE_STATIC);
     writeElement(node.target);
     writeSelector(node.selector);
     // TODO(lry): compact encoding when the arity of the selector and the
     // arguments list are the same
     writeBackReference(node.continuation.definition);
     writeBackReferenceList(node.arguments.length,
                            node.arguments.map((a) => a.definition));
   }
+  
+  void visitInvokeMethod(ir.InvokeMethod node) {
+    writeByte(Pickles.NODE_INVOKE_METHOD);
+    writeBackReference(node.receiver.definition);
+    writeSelector(node.selector);
+    writeBackReference(node.continuation.definition);
+    writeBackReferenceList(node.arguments.length,
+                           node.arguments.map((a) => a.definition));
+  }
+  
+  void visitInvokeConstructor(ir.InvokeConstructor node) {
+    writeByte(Pickles.NODE_INVOKE_CONSTRUCTOR);
+    writeDartType(node.type);
+    writeElement(node.target);
+    writeBackReference(node.continuation.definition);
+    writeBackReferenceList(node.arguments.length,
+                           node.arguments.map((a) => a.definition));
+  }
 
   void visitInvokeContinuation(ir.InvokeContinuation node) {
     writeByte(Pickles.NODE_INVOKE_CONTINUATION);
     writeBackReference(node.continuation.definition);
     writeBackReferenceList(node.arguments.length,
                            node.arguments.map((a) => a.definition));
   }
 
   void visitBranch(ir.Branch node) {
     writeByte(Pickles.NODE_BRANCH);
@@ skipping 52 matching lines @@
   void visitList(ListConstant constant) => abort(constant);
   void visitMap(MapConstant constant) => abort(constant);
   void visitInterceptor(InterceptorConstant constant) => abort(constant);
   void visitDummy(DummyConstant constant) => abort(constant);
   void visitFunction(FunctionConstant constant) => abort(constant);
   void visitType(TypeConstant constant) => abort(constant);
   void visitConstructed(ConstructedConstant constant) => abort(constant);
 
   void abort(Constant value) => throw "Can not pickle constant $value";
 }