Handle Native("...") annotations in KernelBehaviorBuilder.

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 165 matching lines @@
   testForwardingConstructorTyped();
   testForwardingConstructorGeneric();
   testEnum();
   testStaticGenericMethod();
   testInstanceGenericMethod();
   testDynamicPrivateMethodInvoke();
   testJSCall();
   testNativeMethod();
   testNativeMethodCreates();
   testNativeMethodReturns();
+  testNativeField(null);
 }
 
 testEmpty() {}
 testNull() => null;
 testTrue() => true;
 testFalse() => false;
 testInt() => 42;
 testDouble() => 37.5;
 testString() => 'foo';
 testStringInterpolation() => '${0}';
@@ skipping 413 matching lines @@
 }
 
 testDynamicPrivateMethodInvoke([o]) => o._privateMethod();
 testJSCall() => JS('int|bool', '#', null);
 @JSName('foo')
 testNativeMethod() native;
 @Creates('int|Null|JSArray')
 testNativeMethodCreates() native;
 @Returns('String|Null|JSArray')
 testNativeMethodReturns() native;
+
+@Native("NativeClass")
+class NativeClass {
+  @annotation_Creates_SerializedScriptValue
+  final Object field;
+
+  factory NativeClass._() { throw new UnsupportedError("Not supported"); }
+}
+testNativeField(NativeClass c) => c.field;
 ''',
   'sdk/tests/compiler/dart2js_native/helper.dart': '''
+import 'dart:_js_helper';
 class Class {
   const Class.generative();
   factory Class.fact() => null;
   const factory Class.redirect() = Class.generative;
 }
 class GenericClass<X, Y> {
   const GenericClass.generative();
   factory GenericClass.fact() => null;
   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);
-''',
+
+const String _serializedScriptValue =
+    'num|String|bool|'
+    'JSExtendableArray|=Object';
+const annotation_Creates_SerializedScriptValue =
+    const Creates(_serializedScriptValue);''',
 };
 
 main(List<String> args) {
   bool fullTest = args.contains('--full');
   asyncTest(() async {
     enableDebugMode();
     Uri entryPoint =
         Uri.parse('memory:sdk/tests/compiler/dart2js_native/main.dart');
     Compiler compiler = compilerFor(
         entryPoint: entryPoint,
         memorySourceFiles: SOURCE,
         options: [
           fullTest ? Flags.analyzeAll : Flags.analyzeOnly,
           Flags.useKernel,
           Flags.enableAssertMessage
         ]);
     compiler.resolution.retainCachesForTesting = true;
     Expect.isTrue(await compiler.run(entryPoint));
     JavaScriptBackend backend = compiler.backend;
     KernelElementAdapter kernelElementAdapter =
         new KernelWorldBuilder(compiler.reporter, backend.kernelTask.program);
 
     checkLibrary(compiler, kernelElementAdapter, 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, kernelElementAdapter, library,
-            fullTest: fullTest);
-      });
-    }
+    compiler.libraryLoader.libraries.forEach((LibraryElement library) {
+      if (library == compiler.mainApp) return;
+      checkLibrary(compiler, kernelElementAdapter, library, fullTest: fullTest);
+    });
   });
 }
 
 void checkLibrary(Compiler compiler, KernelElementAdapter kernelElementAdapter,
     LibraryElement library,
     {bool fullTest: false}) {
   library.forEachLocalMember((AstElement element) {
     if (element.isClass) {
       ClassElement cls = element;
       cls.forEachLocalMember((AstElement member) {
         checkElement(compiler, kernelElementAdapter, member,
             fullTest: fullTest);
       });
     } else if (element.isTypedef) {
       // Skip typedefs.
     } else {
       checkElement(compiler, kernelElementAdapter, element, fullTest: fullTest);
     }
   });
 }
 
 void checkElement(Compiler compiler, KernelElementAdapter kernelElementAdapter,
     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)') {
-            break;
-          }
-          return;
-        case 'indexed_db':
-          if ('$element' == 'field(ObjectStore#keyPath)') {
-            break;
-          }
-          return;
-        case 'web_audio':
-          return;
-      }
-    }
+  if (!fullTest && element.library.isPlatformLibrary) {
+    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;
@@ skipping 148 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);
 }