Reenable parts of kernel/impact_test

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 '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';
@@ skipping 596 matching lines @@
   const factory GenericClass.redirect() = GenericClass<X, Y>.generative;
 
   Map<X, T> genericMethod<T>(T arg) => { null: arg };
 }
 typedef Typedef();
 typedef X GenericTypedef<X, Y>(Y y);
 ''',
 };
 
 main(List<String> args) {
+  bool fullTest = args.contains('--full');
   asyncTest(() async {
     enableDebugMode();
     Uri entryPoint = Uri.parse('memory:main.dart');
     Compiler compiler = compilerFor(
         entryPoint: entryPoint,
         memorySourceFiles: SOURCE,
         options: [
-          Flags.analyzeAll,
+          fullTest ? Flags.analyzeAll : Flags.analyzeOnly,
           Flags.useKernel,
           Flags.enableAssertMessage
         ]);
     compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
-    checkLibrary(compiler, compiler.mainApp, fullTest: args.contains('--full'));
-    compiler.libraryLoader.libraries.forEach((LibraryElement library) {
-      if (library == compiler.mainApp) return;
-      checkLibrary(compiler, library, fullTest: args.contains('--full'));
-    });
+    checkLibrary(compiler, compiler.mainApp, fullTest: fullTest);
+    if (fullTest) {
+      // TODO(johnniwinther): Handle all libraries for `!fullTest`.
+      compiler.libraryLoader.libraries.forEach((LibraryElement library) {
+        if (library == compiler.mainApp) return;
+        checkLibrary(compiler, library, fullTest: fullTest);
+      });
+    }
   });
 }
 
 void checkLibrary(Compiler compiler, LibraryElement library,
     {bool fullTest: false}) {
   library.forEachLocalMember((AstElement element) {
     if (element.isClass) {
       ClassElement cls = element;
       cls.forEachLocalMember((AstElement member) {
         checkElement(compiler, member, fullTest: fullTest);
       });
     } else if (element.isTypedef) {
       // Skip typedefs.
     } else {
       checkElement(compiler, element, fullTest: fullTest);
     }
   });
 }
 
 void checkElement(Compiler compiler, AstElement element,
     {bool fullTest: false}) {
   if (!fullTest) {
     if (element.library.isPlatformLibrary) {
+      // TODO(johnniwinther): Enqueue these elements for `!fullTest`.
       // Test only selected elements in web-related platform libraries since
       // this unittest otherwise takes too long to run.
       switch (element.library.canonicalUri.path) {
         case 'html':
           if ('$element' ==
               'function(_ValidatingTreeSanitizer#_sanitizeUntrustedElement)') {
             break;
           }
           return;
         case 'web_gl':
           if ('$element' ==
               'function(RenderingContext#getFramebufferAttachmentParameter)') {
-            return;
+            break;
           }
-          break;
+          return;
         case 'indexed_db':
           if ('$element' == 'field(ObjectStore#keyPath)') {
             break;
           }
           return;
         case 'web_audio':
           return;
       }
     }
   }
   if (element.isConstructor) {
     ConstructorElement constructor = element;
     if (constructor.isRedirectingFactory) {
       // Skip redirecting constructors for now; they might not be supported.
       return;
     }
   }
+  if (!fullTest && !compiler.resolution.hasResolutionImpact(element)) {
+    return;
+  }
   ResolutionImpact astImpact = compiler.resolution.getResolutionImpact(element);
   astImpact = laxImpact(compiler, element, astImpact);
   ResolutionImpact kernelImpact = build(compiler, element.resolvedAst);
   Expect.isNotNull(kernelImpact, 'No impact computed for $element');
   testResolutionImpactEquivalence(
       astImpact, kernelImpact, const CheckStrategy());
 }
 
 /// Lax the precision of [impact] to meet expectancy of the corresponding impact
 /// generated from kernel.
@@ skipping 125 matching lines @@
         visitList(type.optionalParameterTypes),
         type.namedParameters,
         visitList(type.namedParameterTypes));
   }
 }
 
 /// Perform unaliasing of all typedefs nested within a [ResolutionDartType].
 ResolutionDartType unalias(ResolutionDartType type) {
   return const Unaliaser().visit(type);
 }