implement `Invocation.typeArguments` in DDC

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1376 matching lines @@
     var type = element.type;
     var virtualFields = _classProperties.virtualFields;
 
     var jsMethods = <JS.Method>[];
     bool hasJsPeer = findAnnotation(element, isJsPeerInterface) != null;
     bool hasIterator = false;
 
     if (type.isObject) {
       // Dart does not use ES6 constructors.
       // Add an error to catch any invalid usage.
-      jsMethods.add(new JS.Method(
-          _propertyName('constructor'),
-          js.call(
-              r'''function() {
+      jsMethods.add(
+          new JS.Method(_propertyName('constructor'), js.call(r'''function() {
                   throw Error("use `new " + #.typeName(#.getReifiedType(this)) +
                       ".new(...)` to create a Dart object");
-              }''',
-              [_runtimeModule, _runtimeModule])));
+              }''', [_runtimeModule, _runtimeModule])));
     }
     for (var m in node.members) {
       if (m is ConstructorDeclaration) {
         if (m.factoryKeyword != null && !_externalOrNative(m)) {
           jsMethods.add(_emitFactoryConstructor(m));
         }
       } else if (m is MethodDeclaration) {
         jsMethods.add(_emitMethodDeclaration(type, m));
 
         if (m.element is PropertyAccessorElement) {
@@ skipping 200 matching lines @@
 
         positionalArgs = new JS.ArrayInitializer([]);
       } else if (property.isSetter) {
         addProperty('isSetter', js.boolean(true));
 
         fnArgs.add(args);
         positionalArgs = new JS.ArrayInitializer([args]);
       }
     }
 
+    var typeParams = _emitTypeFormals(method.type.typeFormals);
+    if (typeParams.isNotEmpty) {
+      addProperty('typeArguments', new JS.ArrayInitializer(typeParams));
+    }
+
     var fnBody =
         js.call('this.noSuchMethod(new #.InvocationImpl.new(#, #, #))', [
       _runtimeModule,
       _declareMemberName(method),
       positionalArgs,
       new JS.ObjectInitializer(invocationProps)
     ]);
 
     if (!method.returnType.isDynamic) {
       fnBody = js.call('#._check(#)', [_emitType(method.returnType), fnBody]);
     }
 
     var fn = _makeGenericFunction(new JS.Fun(
         fnArgs, js.statement('{ return #; }', [fnBody]),
-        typeParams: _emitTypeFormals(method.type.typeFormals)));
+        typeParams: typeParams));
 
-    // TODO(jmesserly): generic type arguments will get dropped.
-    // We have a similar issue with `dgsend` helpers.
     return new JS.Method(
         _declareMemberName(method,
             useExtension: _extensionTypes.isNativeClass(type.element)),
         fn,
         isGetter: method is PropertyAccessorElement && method.isGetter,
         isSetter: method is PropertyAccessorElement && method.isSetter,
         isStatic: false);
   }
 
   /// This is called whenever a derived class needs to introduce a new field,
@@ skipping 519 matching lines @@
 
     return _finishConstructorFunction(params, body, isCallable);
   }
 
   JS.Expression _finishConstructorFunction(
       List<JS.Parameter> params, JS.Block body, isCallable) {
     // We consider a class callable if it inherits from anything with a `call`
     // method. As a result, we can know the callable JS function was created
     // at the first constructor that was hit.
     if (!isCallable) return new JS.Fun(params, body);
-    return js.call(
-        r'''function callableClass(#) {
+    return js.call(r'''function callableClass(#) {
           if (typeof this !== "function") {
             function self(...args) {
               return self.call.apply(self, args);
             }
             self.__proto__ = this.__proto__;
             callableClass.call(self, #);
             return self;
           }
           #
-        }''',
-        [params, params, body]);
+        }''', [params, params, body]);
   }
 
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
     if (name == '') {
       // Default constructors (factory or not) use `new` as their name.
       return _propertyName('new');
     }
     return _emitMemberName(name, isStatic: true);
   }
@@ skipping 3107 matching lines @@
         return js
             .call('#.new(#)', [_emitConstructorAccess(types.symbolType), name]);
       }
     }
 
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
-    var isConst = node.constKeyword != null;
-    JS.Expression emitList() {
-      JS.Expression list = new JS.ArrayInitializer(_visitList(node.elements));
-      ParameterizedType type = node.staticType;
-      var elementType = type.typeArguments.single;
-      // TODO(jmesserly): analyzer will usually infer `List<Object>` because
-      // that is the least upper bound of the element types. So we rarely
-      // generate a plain `List<dynamic>` anymore.
-      if (!elementType.isDynamic || isConst) {
-        // dart.list helper internally depends on _interceptors.JSArray.
-        _declareBeforeUse(_jsArray);
-        if (isConst) {
-          var typeRep = _emitType(elementType);
-          list = _callHelper('constList(#, #)', [list, typeRep]);
-        } else {
-          // Call `new JSArray<E>.of(list)`
-          var jsArrayType = _jsArray.type.instantiate(type.typeArguments);
-          list = js.call('#.of(#)', [_emitType(jsArrayType), list]);
-        }
-      }
-      return list;
+    var elementType = (node.staticType as InterfaceType).typeArguments[0];
+    if (node.constKeyword == null) {
+      return _emitList(elementType, _visitList(node.elements));
     }
+    return _cacheConst(() {
+      // dart.constList helper internally depends on _interceptors.JSArray.
+      _declareBeforeUse(_jsArray);
+      return _callHelper('constList(#, #)', [
+        new JS.ArrayInitializer(_visitList(node.elements)),
+        _emitType(elementType)
+      ]);
+    });
+  }
 
-    if (isConst) return _cacheConst(emitList);
-    return emitList();
+  JS.Expression _emitList(DartType itemType, List<JS.Expression> items) {
+    var list = new JS.ArrayInitializer(items);
+
+    // TODO(jmesserly): analyzer will usually infer `List<Object>` because
+    // that is the least upper bound of the element types. So we rarely
+    // generate a plain `List<dynamic>` anymore.
+    if (itemType.isDynamic) return list;
+
+    // Call `new JSArray<E>.of(list)`
+    var arrayType = _jsArray.type.instantiate([itemType]);
+    return js.call('#.of(#)', [_emitType(arrayType), list]);
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
     JS.Expression emitMap() {
       var entries = node.entries;
       Object mapArguments = null;
       var type = node.staticType as InterfaceType;
       var typeArgs = type.typeArguments;
@@ skipping 621 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }