Handle dart:html in kernel_impact

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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 '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js_backend/backend_helpers.dart';
 import '../js_backend/js_backend.dart';
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
-import '../native/native.dart' show NativeBehavior;
+import '../native/native.dart' show NativeBehavior, TypeLookup;
 import '../resolution/tree_elements.dart';
 import '../tree/tree.dart' as ast;
 import '../types/masks.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
 import '../world.dart';
 import 'locals_handler.dart';
 import 'types.dart';
@@ skipping 322 matching lines @@
 
   /// Return `true` if [node] is the `dart:_foreign_helper` library.
   bool isForeignLibrary(ir.Library node) {
     return node.importUri == BackendHelpers.DART_FOREIGN_HELPER;
   }
 
   /// Looks up [typeName] for use in the spec-string of a `JS` called.
   // TODO(johnniwinther): Use this in [NativeBehavior] instead of calling the
   // `ForeignResolver`.
   // TODO(johnniwinther): Cache the result to avoid redundant lookups?
-  DartType _typeLookup(String typeName) {
-    DartType findIn(Uri uri) {
-      LibraryElement library = _compiler.libraryLoader.lookupLibrary(uri);
-      if (library != null) {
-        Element element = library.find(typeName);
-        if (element != null && element.isClass) {
-          ClassElement cls = element;
-          return cls.rawType;
+  TypeLookup _typeLookup({bool resolveAsRaw: true}) {
+    return (String typeName) {
+      DartType findIn(Uri uri) {
+        LibraryElement library = _compiler.libraryLoader.lookupLibrary(uri);
+        if (library != null) {
+          Element element = library.find(typeName);
+          if (element != null && element.isClass) {
+            ClassElement cls = element;
+            // TODO(johnniwinther): Align semantics.
+            return resolveAsRaw ? cls.rawType : cls.thisType;
+          }
         }
+        return null;
       }
-      return null;
-    }
 
-    DartType type = findIn(Uris.dart_core);
-    type ??= findIn(BackendHelpers.DART_JS_HELPER);
-    type ??= findIn(BackendHelpers.DART_INTERCEPTORS);
-    type ??= findIn(BackendHelpers.DART_ISOLATE_HELPER);
-    type ??= findIn(Uris.dart_collection);
-    type ??= findIn(Uris.dart_html);
-    return type;
+      DartType type = findIn(Uris.dart_core);
+      type ??= findIn(BackendHelpers.DART_JS_HELPER);
+      type ??= findIn(BackendHelpers.DART_INTERCEPTORS);
+      type ??= findIn(BackendHelpers.DART_ISOLATE_HELPER);
+      type ??= findIn(Uris.dart_collection);
+      type ??= findIn(Uris.dart_html);
+      type ??= findIn(Uris.dart_svg);
+      type ??= findIn(Uris.dart_web_audio);
+      type ??= findIn(Uris.dart_web_gl);
+      return type;
+    };
   }
 
   String _getStringArgument(ir.StaticInvocation node, int index) {
     return node.arguments.positional[index].accept(new Stringifier());
   }
 
   /// Computes the [NativeBehavior] for a call to the [JS] function.
   // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForJsCall(ir.StaticInvocation node) {
     if (node.arguments.positional.length < 2 ||
         node.arguments.named.isNotEmpty) {
       reporter.reportErrorMessage(
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS);
       return new NativeBehavior();
     }
     String specString = _getStringArgument(node, 0);
     if (specString == null) {
       reporter.reportErrorMessage(
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_FIRST);
       return new NativeBehavior();
     }
 
     String codeString = _getStringArgument(node, 1);
     if (codeString == null) {
       reporter.reportErrorMessage(
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
       return new NativeBehavior();
     }
 
-    return NativeBehavior.ofJsCall(specString, codeString, _typeLookup,
-        CURRENT_ELEMENT_SPANNABLE, reporter, _compiler.coreTypes);
+    return NativeBehavior.ofJsCall(
+        specString,
+        codeString,
+        _typeLookup(resolveAsRaw: true),
+        CURRENT_ELEMENT_SPANNABLE,
+        reporter,
+        _compiler.coreTypes);
   }
 
   /// Computes the [NativeBehavior] for a call to the [JS_BUILTIN] function.
   // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForJsBuiltinCall(ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin expression has no type.");
       return new NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin is missing name.");
       return new NativeBehavior();
     }
     String specString = _getStringArgument(node, 0);
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new NativeBehavior();
     }
-    return NativeBehavior.ofJsBuiltinCall(specString, _typeLookup,
-        CURRENT_ELEMENT_SPANNABLE, reporter, _compiler.coreTypes);
+    return NativeBehavior.ofJsBuiltinCall(
+        specString,
+        _typeLookup(resolveAsRaw: true),
+        CURRENT_ELEMENT_SPANNABLE,
+        reporter,
+        _compiler.coreTypes);
   }
 
   /// Computes the [NativeBehavior] for a call to the [JS_EMBEDDED_GLOBAL]
   /// function.
   // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForJsEmbeddedGlobalCall(
       ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
           "JS embedded global expression has no type.");
       return new NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS embedded global is missing name.");
       return new NativeBehavior();
     }
     if (node.arguments.positional.length > 2 ||
         node.arguments.named.isNotEmpty) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
           "JS embedded global has more than 2 arguments.");
       return new NativeBehavior();
     }
     String specString = _getStringArgument(node, 0);
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new NativeBehavior();
     }
-    return NativeBehavior.ofJsEmbeddedGlobalCall(specString, _typeLookup,
-        CURRENT_ELEMENT_SPANNABLE, reporter, _compiler.coreTypes);
+    return NativeBehavior.ofJsEmbeddedGlobalCall(
+        specString,
+        _typeLookup(resolveAsRaw: true),
+        CURRENT_ELEMENT_SPANNABLE,
+        reporter,
+        _compiler.coreTypes);
   }
 
   /// Returns `true` is [node] has a `@Native(...)` annotation.
   // TODO(johnniwinther): Cache this for later use.
   bool isNative(ir.Class node) {
     for (ir.Expression annotation in node.annotations) {
       if (annotation is ir.ConstructorInvocation) {
         ConstructorElement target = getElement(annotation.target).declaration;
         if (target.enclosingClass ==
             _compiler.commonElements.nativeAnnotationClass) {
           return true;
         }
       }
     }
     return false;
   }
 
   /// Computes the native behavior for reading the native [field].
   // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field) {
     DartType type = getDartType(field.type);
     List<ConstantExpression> metadata = getMetadata(field.annotations);
-    return NativeBehavior.ofFieldLoad(
-        CURRENT_ELEMENT_SPANNABLE, type, metadata, _typeLookup, _compiler,
+    return NativeBehavior.ofFieldLoad(CURRENT_ELEMENT_SPANNABLE, type, metadata,
+        _typeLookup(resolveAsRaw: false), _compiler,
         isJsInterop: false);
   }
 
   /// Computes the native behavior for writing to the native [field].
   // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
     DartType type = getDartType(field.type);
     return NativeBehavior.ofFieldStore(type, _compiler.resolution);
   }
 
   /// Computes the native behavior for calling [procedure].
   // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure) {
     DartType type = getFunctionType(procedure.function);
     List<ConstantExpression> metadata = getMetadata(procedure.annotations);
-    return NativeBehavior.ofMethod(
-        CURRENT_ELEMENT_SPANNABLE, type, metadata, _typeLookup, _compiler,
+    return NativeBehavior.ofMethod(CURRENT_ELEMENT_SPANNABLE, type, metadata,
+        _typeLookup(resolveAsRaw: false), _compiler,
         isJsInterop: false);
   }
 }
 
 /// Kinds of foreign functions.
 enum ForeignKind {
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
@@ skipping 115 matching lines @@
     return new ConstructedConstantExpression(
         constructor.enclosingClass.thisType.createInstantiation(typeArguments),
         constructor,
         new CallStructure(
             node.arguments.positional.length + argumentNames.length,
             argumentNames),
         arguments);
   }
 
   @override
+  ConstantExpression visitStaticGet(ir.StaticGet node) {
+    Element element = astAdapter.getMember(node.target);
+    if (element.isField) {
+      return new VariableConstantExpression(element);
+    }
+    astAdapter.reporter.internalError(
+        CURRENT_ELEMENT_SPANNABLE, "Unexpected constant target: $element.");
+    return null;
+  }
+
+  @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 }