Revert "Update impact_test to use --use-kernel"

This reverts commit 7222ff6.

Change-Id: I2c419961230f1d7e240fc6dbb892fa8e43cb6896
Reviewed-on: https://dart-review.googlesource.com/5201
Reviewed-by: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/compiler/lib/src/resolution/constructors.dart

@@ -449,19 +449,6 @@ class InitializerResolver {
     if (!resolvedSuper) {
       constructorInvocation = resolveImplicitSuperConstructorSend();
     }
-    constructor.enclosingClass
-        .forEachInstanceField((ClassElement declarer, FieldElement field) {
-      if (declarer != constructor.enclosingClass) return;
-
-      if (!initialized.containsKey(field)) {
-        visitor.resolution.ensureResolved(field);
-        if (field.isFinal && field.initializer == null) {
-          registry.registerStaticUse(new StaticUse.fieldInit(field));
-          registry.registerConstantLiteral(new NullConstantExpression());
-        }
-      }
-    });
-
     if (isConst && isValidAsConstant) {
       constructor.enclosingClass.forEachInstanceField((_, FieldElement field) {
         if (!fieldInitializers.containsKey(field)) {

pkg/compiler/lib/src/resolution/members.dart

@@ -443,8 +443,7 @@ class ResolverVisitor extends MappingVisitor<ResolutionResult> {
             element.constant = result.constant;
           }
         } else {
-          registry.registerConstantLiteral(
-              element.constant = new NullConstantExpression());
+          element.constant = new NullConstantExpression();
         }
       }
       VariableDefinitions variableDefinitions = parameterNodes.head;

pkg/compiler/lib/src/serialization/equivalence.dart

@@ -1050,24 +1050,15 @@ class ConstantValueEquivalence
 /// Tests the equivalence of [impact1] and [impact2] using [strategy].
 bool testResolutionImpactEquivalence(
     ResolutionImpact impact1, ResolutionImpact impact2,
-    {TestStrategy strategy = const TestStrategy(),
-    Iterable<ConstantExpression> filterConstantLiterals(
-        Iterable<ConstantExpression> constants,
-        {bool fromFirstImpact})}) {
+    {TestStrategy strategy = const TestStrategy()}) {
   return strategy.testSets(impact1, impact2, 'constSymbolNames',
           impact1.constSymbolNames, impact2.constSymbolNames) &&
       strategy.testSets(
           impact1,
           impact2,
           'constantLiterals',
-          filterConstantLiterals != null
-              ? filterConstantLiterals(impact1.constantLiterals,
-                  fromFirstImpact: true)
-              : impact1.constantLiterals,
-          filterConstantLiterals != null
-              ? filterConstantLiterals(impact2.constantLiterals,
-                  fromFirstImpact: false)
-              : impact2.constantLiterals,
+          impact1.constantLiterals,
+          impact2.constantLiterals,
           areConstantsEquivalent) &&
       strategy.testSets(
           impact1,

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

@@ -121,10 +121,7 @@ class KernelImpactBuilder extends ir.Visitor {
           field.initializer is! ir.NullLiteral) {
         impactBuilder.registerFeature(Feature.LAZY_FIELD);
       }
-    } else {
-      impactBuilder.registerConstantLiteral(new NullConstantExpression());
     }
-
     if (field.isInstanceMember &&
         elementAdapter.isNativeClass(field.enclosingClass)) {
       MemberEntity member = elementAdapter.getMember(field);
@@ -430,13 +427,7 @@ class KernelImpactBuilder extends ir.Visitor {
 
   @override
   void visitDirectMethodInvocation(ir.DirectMethodInvocation node) {
-    _visitArguments(node.arguments);
-    // TODO(johnniwinther): Restrict the dynamic use to only match the known
-    // target.
-    impactBuilder.registerDynamicUse(new DynamicUse(
-        new Selector.call(elementAdapter.getMember(node.target).memberName,
-            elementAdapter.getCallStructure(node.arguments)),
-        null));
+    handleSuperInvocation(node.name, node.target, node.arguments);
   }
 
   @override
@@ -465,11 +456,7 @@ class KernelImpactBuilder extends ir.Visitor {
 
   @override
   void visitDirectPropertyGet(ir.DirectPropertyGet node) {
-    // TODO(johnniwinther): Restrict the dynamic use to only match the known
-    // target.
-    impactBuilder.registerDynamicUse(new DynamicUse(
-        new Selector.getter(elementAdapter.getMember(node.target).memberName),
-        null));
+    handleSuperGet(null, node.target);
   }
 
   @override
@@ -497,12 +484,7 @@ class KernelImpactBuilder extends ir.Visitor {
 
   @override
   void visitDirectPropertySet(ir.DirectPropertySet node) {
-    visitNode(node.value);
-    // TODO(johnniwinther): Restrict the dynamic use to only match the known
-    // target.
-    impactBuilder.registerDynamicUse(new DynamicUse(
-        new Selector.setter(elementAdapter.getMember(node.target).memberName),
-        null));
+    handleSuperSet(null, node.target, node.value);
   }
 
   @override
@@ -569,22 +551,6 @@ class KernelImpactBuilder extends ir.Visitor {
     impactBuilder.registerStaticUse(
         new StaticUse.closure(elementAdapter.getLocalFunction(node)));
     handleSignature(node.function);
-    // TODO(johnniwinther): Remove this when #30629 is closed.
-    switch (node.function.asyncMarker) {
-      case ir.AsyncMarker.Async:
-        impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(
-            elementAdapter.commonElements.futureType()));
-        break;
-      case ir.AsyncMarker.AsyncStar:
-        impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(
-            elementAdapter.commonElements.streamType()));
-        break;
-      case ir.AsyncMarker.SyncStar:
-        impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(
-            elementAdapter.commonElements.iterableType()));
-        break;
-      default:
-    }
     handleAsyncMarker(node.function.asyncMarker);
     visitNode(node.function.body);
   }

tests/compiler/dart2js/kernel/closed_world2_test.dart

@@ -197,9 +197,8 @@ Future<ResultKind> mainInternal(List<String> args,
   ClosedWorld closedWorld1 = compiler1.resolutionWorldBuilder.closeWorld();
   BackendUsage backendUsage1 = closedWorld1.backendUsage;
 
-  Pair<Compiler, Compiler> compilers = await analyzeOnly(
-      entryPoint, memorySourceFiles,
-      printSteps: true, useKernelInSsa: true);
+  Pair<Compiler, Compiler> compilers =
+      await analyzeOnly(entryPoint, memorySourceFiles, printSteps: true);
   Compiler compiler = compilers.a;
   compiler.resolutionWorldBuilder.closeWorld();
   ElementEnvironment environment1 =

tests/compiler/dart2js/kernel/compiler_helper.dart

@@ -18,7 +18,6 @@ import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/kernel/element_map.dart';
 import 'package:compiler/src/kernel/kernel_strategy.dart';
 import 'package:compiler/src/library_loader.dart';
-import 'package:compiler/src/resolution/enum_creator.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/util/util.dart';
 import 'package:kernel/ast.dart' as ir;
@@ -66,20 +65,18 @@ Future<List<CompileFunction>> compileMultiple(List<String> sources) async {
 /// to create the IR and the kernel based compiler.
 Future<Pair<Compiler, Compiler>> analyzeOnly(
     Uri entryPoint, Map<String, String> memorySourceFiles,
-    {bool useKernelInSsa: false, bool printSteps: false}) async {
+    {bool printSteps: false}) async {
   if (printSteps) {
     print('---- analyze-all -------------------------------------------------');
   }
-  EnumCreator.matchKernelRepresentationForTesting = !useKernelInSsa;
-  List<String> options = [Flags.analyzeAll, Flags.enableAssertMessage];
-  if (useKernelInSsa) {
-    // Generate kernel IR. Needed for [compiler2] when for [useKernelInSsa].
-    options.add(Flags.useKernelInSsa);
-  }
   Compiler compiler = compilerFor(
       entryPoint: entryPoint,
       memorySourceFiles: memorySourceFiles,
-      options: options);
+      options: [
+        Flags.analyzeAll,
+        Flags.useKernelInSsa,
+        Flags.enableAssertMessage
+      ]);
   compiler.resolution.retainCachesForTesting = true;
   await compiler.run(entryPoint);
 
@@ -92,15 +89,13 @@ Future<Pair<Compiler, Compiler>> analyzeOnly(
       options: [Flags.analyzeOnly, Flags.enableAssertMessage, Flags.useKernel]);
   ElementResolutionWorldBuilder.useInstantiationMap = true;
   compiler2.resolution.retainCachesForTesting = true;
-  if (useKernelInSsa) {
-    KernelFrontEndStrategy frontendStrategy = compiler2.frontendStrategy;
-    KernelToElementMapForImpact elementMap = frontendStrategy.elementMap;
-    compiler2.libraryLoader = new MemoryKernelLibraryLoaderTask(
-        elementMap,
-        compiler2.reporter,
-        compiler2.measurer,
-        compiler.backend.kernelTask.program);
-  }
+  KernelFrontEndStrategy frontendStrategy = compiler2.frontendStrategy;
+  KernelToElementMapForImpact elementMap = frontendStrategy.elementMap;
+  compiler2.libraryLoader = new MemoryKernelLibraryLoaderTask(
+      elementMap,
+      compiler2.reporter,
+      compiler2.measurer,
+      compiler.backend.kernelTask.program);
   await compiler2.run(entryPoint);
   return new Pair<Compiler, Compiler>(compiler, compiler2);
 }