Revert "Revert "dart2js: Add a type parameter to class Reference....""

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 335 matching lines @@
   ir.Primitive _continueWithExpression(ir.Expression build(ir.Continuation k)) {
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression expression = build(k);
     add(new ir.LetCont(k, expression));
     return v;
   }
 
   ir.Primitive _buildInvokeStatic(Element element,
                                   Selector selector,
-                                  List<ir.Definition> arguments) {
+                                  List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
 
   ir.Primitive _buildInvokeSuper(Selector selector,
-                                 List<ir.Definition> arguments) {
+                                 List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeSuperMethod(selector, k, arguments));
   }
 
   ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
                                    Selector selector,
-                                   List<ir.Definition> arguments) {
+                                   List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethod(receiver, selector, k, arguments));
   }
 
 
   /// Create a constant literal from [constant].
   ir.Constant buildConstantLiteral(ConstantExpression constant) {
     assert(isOpen);
     ir.Constant prim = new ir.Constant(constant);
@@ skipping 145 matching lines @@
       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) {
+                                    List<ir.Primitive> arguments) {
     return _buildInvokeSuper(selector, arguments);
   }
 
   /// Create a getter invocation on the super class where the getter name is
   /// defined by [selector].
   ir.Primitive buildSuperGet(Selector selector) {
     assert(selector.isGetter);
-    return _buildInvokeSuper(selector, const <ir.Definition>[]);
+    return _buildInvokeSuper(selector, const <ir.Primitive>[]);
   }
 
   /// Create a setter invocation on the super class where the setter name and
   /// argument are defined by [selector] and [value], respectively.
   ir.Primitive buildSuperSet(Selector selector, ir.Primitive value) {
     assert(selector.isSetter);
-    _buildInvokeSuper(selector, <ir.Definition>[value]);
+    _buildInvokeSuper(selector, <ir.Primitive>[value]);
     return value;
   }
 
   /// Create an index set invocation on the super class with the provided
   /// [index] and [value].
   ir.Primitive buildSuperIndexSet(ir.Primitive index,
                                   ir.Primitive value) {
-    _buildInvokeSuper(new Selector.indexSet(), <ir.Definition>[index, value]);
+    _buildInvokeSuper(new Selector.indexSet(), <ir.Primitive>[index, value]);
     return value;
   }
 
   /// Create a dynamic invocation on [receiver] where the method name and
   /// argument structure are defined by [selector] and the argument values are
   /// defined by [arguments].
-  ir.Primitive buildDynamicInvocation(ir.Definition receiver,
+  ir.Primitive buildDynamicInvocation(ir.Primitive receiver,
                                       Selector selector,
-                                      List<ir.Definition> arguments) {
+                                      List<ir.Primitive> arguments) {
     return _buildInvokeDynamic(receiver, selector, arguments);
   }
 
   /// Create a dynamic getter invocation on [receiver] where the getter name is
   /// defined by [selector].
   ir.Primitive buildDynamicGet(ir.Primitive receiver, Selector selector) {
     assert(selector.isGetter);
-    return _buildInvokeDynamic(receiver, selector, const <ir.Definition>[]);
+    return _buildInvokeDynamic(receiver, selector, const <ir.Primitive>[]);
   }
 
   /// Create a dynamic setter invocation on [receiver] where the setter name and
   /// argument are defined by [selector] and [value], respectively.
   ir.Primitive buildDynamicSet(ir.Primitive receiver,
                                Selector selector,
                                ir.Primitive value) {
     assert(selector.isSetter);
-    _buildInvokeDynamic(receiver, selector, <ir.Definition>[value]);
+    _buildInvokeDynamic(receiver, selector, <ir.Primitive>[value]);
     return value;
   }
 
   /// Create a dynamic index set invocation on [receiver] with the provided
   /// [index] and [value].
   ir.Primitive  buildDynamicIndexSet(ir.Primitive receiver,
                                      ir.Primitive index,
                                      ir.Primitive value) {
     _buildInvokeDynamic(
-        receiver, new Selector.indexSet(), <ir.Definition>[index, value]);
+        receiver, new Selector.indexSet(), <ir.Primitive>[index, value]);
     return value;
   }
 
   /// Create a static invocation of [element] where argument structure is
   /// defined by [selector] and the argument values are defined by [arguments].
   ir.Primitive buildStaticInvocation(Element element,
                                      Selector selector,
-                                     List<ir.Definition> arguments) {
+                                     List<ir.Primitive> arguments) {
     return _buildInvokeStatic(element, selector, arguments);
   }
 
   /// Create a static getter invocation of [element] where the getter name is
   /// defined by [selector].
   ir.Primitive buildStaticGet(Element element, Selector selector) {
     assert(selector.isGetter);
-    return _buildInvokeStatic(element, selector, const <ir.Definition>[]);
+    return _buildInvokeStatic(element, selector, const <ir.Primitive>[]);
   }
 
   /// Create a static setter invocation of [element] where the setter name and
   /// argument are defined by [selector] and [value], respectively.
   ir.Primitive buildStaticSet(Element element,
                               Selector selector,
                               ir.Primitive value) {
     assert(selector.isSetter);
-    _buildInvokeStatic(element, selector, <ir.Definition>[value]);
+    _buildInvokeStatic(element, selector, <ir.Primitive>[value]);
     return value;
   }
 
   /// Create a constructor invocation of [element] on [type] where the
   /// constructor name and argument structure are defined by [selector] and the
   /// argument values are defined by [arguments].
   ir.Primitive buildConstructorInvocation(FunctionElement element,
                                           Selector selector,
                                           DartType type,
-                                          List<ir.Definition> arguments) {
+                                          List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector, k, arguments));
   }
 
   /// Create a string concatenation of the [arguments].
-  ir.Primitive buildStringConcatenation(List<ir.Definition> arguments) {
+  ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   /// Create a read access of [local].
   ir.Primitive buildLocalGet(LocalElement local) {
     assert(isOpen);
     if (isClosureVariable(local)) {
       ir.Primitive result = new ir.GetClosureVariable(local);
@@ skipping 754 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }