Handle generic factory constructors in kernel_impact

pkg/compiler/lib/src/ssa/kernel_impact.dart

 // Copyright (c) 2016, 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 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 177 matching lines @@
     }
     for (ir.NamedExpression argument in arguments.named) {
       argument.value.accept(this);
     }
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     _visitArguments(invocation.arguments);
     Element target = astAdapter.getElement(invocation.target).declaration;
-    impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
-        target, astAdapter.getCallStructure(invocation.arguments)));
+    if (target.isFactoryConstructor) {
+      impactBuilder.registerStaticUse(new StaticUse.constructorInvoke(
+          target, astAdapter.getCallStructure(invocation.arguments)));
+      // TODO(johnniwinther): We should not mark the type as instantiated but
+      // rather follow the type arguments directly.

[Harry Terkelsen, 2016/09/16 16:58:30]

What do you mean by "follow the type arguments"? I get that we don't want to
mark the types as instantiated, but don't follow what the proposed alternative
is

[Johnni Winther, 2016/09/19 08:10:18]

Consider this:

abstract class A<T> {
  factory A.regular() => new B<T>();
  factory A.redirect() = B<T>;
}

class B<T> implements A<T> {}

main() {
  print(new A<int>.regular() is B<int>);
  print(new A<String>.redirect() is B<String>);
}

To track that B is actually instantiated as B<int> and B<String> we need to
follow the type arguments passed to A.regular and A.redirect to B. Currently, we
only do this soundly if we register A<int> and A<String> as instantiated. We
should instead register that A.T is instantiated as int and String.

+      ClassElement cls =
+          astAdapter.getElement(invocation.target.enclosingClass);
+      List<DartType> typeArguments =
+          astAdapter.getDartTypes(invocation.arguments.types);
+      impactBuilder.registerTypeUse(
+          new TypeUse.instantiation(new InterfaceType(cls, typeArguments)));
+      if (typeArguments.any((DartType type) => !type.isDynamic)) {
+        impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
+      }
+    } else {
+      impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
+          target, astAdapter.getCallStructure(invocation.arguments)));
+    }
   }
 
   @override
   void visitStaticGet(ir.StaticGet node) {
     Element target = astAdapter.getElement(node.target).declaration;
     impactBuilder.registerStaticUse(new StaticUse.staticGet(target));
   }
 
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
@@ skipping 26 matching lines @@
   @override
   void visitAssertStatement(ir.AssertStatement node) {
     impactBuilder.registerFeature(
         node.message != null ? Feature.ASSERT_WITH_MESSAGE : Feature.ASSERT);
     node.visitChildren(this);
   }
 
   @override
   void defaultNode(ir.Node node) => node.visitChildren(this);
 }