Handle const constructor invocation in kernel_impact.

tests/compiler/dart2js/kernel/impact_test.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.
 
 library dart2js.kernel.impact_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/dart_types.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/resolution/registry.dart';
 import 'package:compiler/src/ssa/kernel_impact.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/universe/call_structure.dart';
 import 'package:compiler/src/universe/feature.dart';
 import 'package:compiler/src/universe/use.dart';
 import 'package:expect/expect.dart';
 import '../memory_compiler.dart';
 import '../serialization/test_helper.dart';
@@ skipping 101 matching lines @@
   testConstructorInvokeGenericRaw();
   testConstructorInvokeGenericDynamic();
   testFactoryInvoke();
   testFactoryInvokeGeneric();
   testFactoryInvokeGenericRaw();
   testFactoryInvokeGenericDynamic();
   testRedirectingFactoryInvoke();
   testRedirectingFactoryInvokeGeneric();
   testRedirectingFactoryInvokeGenericRaw();
   testRedirectingFactoryInvokeGenericDynamic();
+  testConstRedirectingFactoryInvoke();
+  testConstRedirectingFactoryInvokeGeneric();
+  testConstRedirectingFactoryInvokeGenericRaw();
+  testConstRedirectingFactoryInvokeGenericDynamic();
 }
 
 testEmpty() {}
 testNull() => null;
 testTrue() => true;
 testFalse() => false;
 testInt() => 42;
 testDouble() => 37.5;
 testString() => 'foo';
 testStringInterpolation() => '${0}';
@@ skipping 248 matching lines @@
 }
 testRedirectingFactoryInvokeGeneric() {
   new GenericClass<int, String>.redirect();
 }
 testRedirectingFactoryInvokeGenericRaw() {
   new GenericClass.redirect();
 }
 testRedirectingFactoryInvokeGenericDynamic() {
   new GenericClass<dynamic, dynamic>.redirect();
 }
+testConstRedirectingFactoryInvoke() {
+  const Class.redirect();
+}
+testConstRedirectingFactoryInvokeGeneric() {
+  const GenericClass<int, String>.redirect();
+}
+testConstRedirectingFactoryInvokeGenericRaw() {
+  const GenericClass.redirect();
+}
+testConstRedirectingFactoryInvokeGenericDynamic() {
+  const GenericClass<dynamic, dynamic>.redirect();
+}
 ''',
   'helper.dart': '''
 class Class {
-  Class.generative();
+  const Class.generative();
   factory Class.fact() => null;
-  factory Class.redirect() = Class.generative;
+  const factory Class.redirect() = Class.generative;
 }
 class GenericClass<X, Y> {
-  GenericClass.generative();
+  const GenericClass.generative();
   factory GenericClass.fact() => null;
-  factory GenericClass.redirect() = GenericClass.generative;
+  const factory GenericClass.redirect() = GenericClass<X, Y>.generative;
 }
 typedef Typedef();
 typedef X GenericTypedef<X, Y>(Y y);
 ''',
 };
 
 main(List<String> args) {
   asyncTest(() async {
     enableDebugMode();
     Uri entryPoint = Uri.parse('memory:main.dart');
@@ skipping 31 matching lines @@
   testResolutionImpactEquivalence(
       astImpact, kernelImpact, const CheckStrategy());
 }
 
 /// Lax the precision of [impact] to meet expectancy of the corresponding impact
 /// generated from kernel.
 ResolutionImpact laxImpact(
     Compiler compiler, AstElement element, ResolutionImpact impact) {
   ResolutionWorldImpactBuilder builder =
       new ResolutionWorldImpactBuilder('Lax impact of ${element}');
-  impact.staticUses.forEach(builder.registerStaticUse);
+  for (StaticUse staticUse in impact.staticUses) {
+    switch (staticUse.kind) {
+      case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
+        ConstructorElement constructor = staticUse.element;
+        ConstructorElement effectiveTarget = constructor.effectiveTarget;
+        DartType effectiveTargetType =
+            constructor.computeEffectiveTargetType(staticUse.type);
+        builder.registerStaticUse(
+            new StaticUse.typedConstructorInvoke(effectiveTarget, null, effectiveTargetType));

[Harry Terkelsen, 2016/10/07 15:53:21]

long line

[Harry Terkelsen, 2016/10/07 15:53:21]

why do we lose the distinction between const and non-const constructors in
kernel?

[Johnni Winther, 2016/10/10 09:58:12]

Done.

[Johnni Winther, 2016/10/10 09:58:12]

Fixed.

+        break;
+      default:
+        builder.registerStaticUse(staticUse);
+        break;
+    }
+  }
   impact.dynamicUses.forEach(builder.registerDynamicUse);
   for (TypeUse typeUse in impact.typeUses) {
     if (typeUse.type.isTypedef) {
       typeUse = new TypeUse.internal(typeUse.type.unaliased, typeUse.kind);
     }
     builder.registerTypeUse(typeUse);
   }
   impact.constantLiterals.forEach(builder.registerConstantLiteral);
   impact.constSymbolNames.forEach(builder.registerConstSymbolName);
   impact.listLiterals.forEach(builder.registerListLiteral);
   impact.mapLiterals.forEach(builder.registerMapLiteral);
   for (Feature feature in impact.features) {
     switch (feature) {
       case Feature.STRING_INTERPOLATION:
       case Feature.STRING_JUXTAPOSITION:
         // These are both converted into a string concatenation in kernel so
-        // we cannot tell the diferrence.
+        // we cannot tell the difference.
         builder.registerFeature(Feature.STRING_INTERPOLATION);
         builder.registerFeature(Feature.STRING_JUXTAPOSITION);
         break;
       case Feature.FALL_THROUGH_ERROR:
         LibraryElement library =
             compiler.libraryLoader.lookupLibrary(Uris.dart_core);
         ClassElement cls =
             library.implementation.localLookup('FallThroughError');
         ConstructorElement constructor = cls.lookupConstructor('');
-        builder.registerTypeUse(new TypeUse.instantiation(cls.thisType));
-        builder.registerStaticUse(new StaticUse.constructorInvoke(
-            constructor, CallStructure.NO_ARGS));
+        builder.registerStaticUse(new StaticUse.typedConstructorInvoke(
+            constructor, CallStructure.NO_ARGS, cls.thisType));
         builder.registerFeature(Feature.THROW_EXPRESSION);
         break;
       default:
         builder.registerFeature(feature);
         break;
     }
   }
   impact.nativeData.forEach(builder.registerNativeData);
   return builder;
 }