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

pkg/analyzer2dart/lib/src/cps_generator.dart

 // Copyright (c) 2014, 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 analyzer2dart.cps_generator;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'package:compiler/src/dart_types.dart' as dart2js;
 import 'package:compiler/src/elements/elements.dart' as dart2js;
@@ skipping 39 matching lines @@
         // accessed from an inner function.
         irBuilder.createParameter(converter.convertElement(parameter));
       });
       // Visit the body directly to avoid processing the signature as
       // expressions.
       visit(node.functionExpression.body);
       return irBuilder.buildFunctionDefinition(element, const []);
     });
   }
 
-  List<ir.Definition> visitArguments(ArgumentList argumentList) {
-    List<ir.Definition> arguments = <ir.Definition>[];
+  List<ir.Primitive> visitArguments(ArgumentList argumentList) {
+    List<ir.Primitive> arguments = <ir.Primitive>[];
     for (Expression argument in argumentList.arguments) {
-      ir.Definition value = build(argument);
+      ir.Primitive value = build(argument);
       if (value == null) {
         giveUp(argument,
             'Unsupported argument: $argument (${argument.runtimeType}).');
       }
       arguments.add(value);
     }
     return arguments;
   }
 
   @override
   ir.Node visitMethodInvocation(MethodInvocation node) {
     // Overridden to avoid eager visits of the receiver and arguments.
     return handleMethodInvocation(node);
   }
 
   @override
   ir.Primitive visitDynamicInvocation(MethodInvocation node,
                                       AccessSemantics semantics) {
     // TODO(johnniwinther): Handle implicit `this`.
     ir.Primitive receiver = build(semantics.target);
-    List<ir.Definition> arguments = visitArguments(node.argumentList);
+    List<ir.Primitive> arguments = visitArguments(node.argumentList);
     return irBuilder.buildDynamicInvocation(
         receiver,
         createSelectorFromMethodInvocation(
             node.argumentList, node.methodName.name),
         arguments);
   }
 
   @override
   ir.Primitive visitStaticMethodInvocation(MethodInvocation node,
                                            AccessSemantics semantics) {
     analyzer.Element staticElement = semantics.element;
     dart2js.Element element = converter.convertElement(staticElement);
-    List<ir.Definition> arguments = visitArguments(node.argumentList);
+    List<ir.Primitive> arguments = visitArguments(node.argumentList);
     return irBuilder.buildStaticInvocation(
         element,
         createSelectorFromMethodInvocation(
             node.argumentList, node.methodName.name),
         arguments);
   }
 
   @override
   ir.Primitive visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     analyzer.Element staticElement = node.staticElement;
     if (staticElement != null) {
       dart2js.Element element = converter.convertElement(staticElement);
       dart2js.DartType type = converter.convertType(node.staticType);
-      List<ir.Definition> arguments = visitArguments(node.argumentList);
+      List<ir.Primitive> arguments = visitArguments(node.argumentList);
       String name = '';
       if (node.constructorName.name != null) {
         name = node.constructorName.name.name;
       }
       return irBuilder.buildConstructorInvocation(
           element,
           createSelectorFromMethodInvocation(node.argumentList, name),
           type,
           arguments);
     }
@@ skipping 128 matching lines @@
     return irBuilder.buildStaticGet(target,
         new Selector.getter(target.name, target.library));
   }
 
   ir.Primitive handleBinaryExpression(BinaryExpression node,
                                       String op) {
     ir.Primitive left = build(node.leftOperand);
     ir.Primitive right = build(node.rightOperand);
     Selector selector = new Selector.binaryOperator(op);
     return irBuilder.buildDynamicInvocation(
-        left, selector, <ir.Definition>[right]);
+        left, selector, <ir.Primitive>[right]);
   }
 
   ir.Node handleLazyOperator(BinaryExpression node, {bool isLazyOr: false}) {
     return irBuilder.buildLogicalOperator(
         build(node.leftOperand),
         subbuild(node.rightOperand),
         isLazyOr: isLazyOr);
   }
 
   @override
@@ skipping 124 matching lines @@
   }
 
   @override
   ir.Primitive visitAsExpression(AsExpression node) {
     return irBuilder.buildTypeOperator(
         visit(node.expression),
         converter.convertType(node.type.type),
         isTypeTest: false);
   }
 }