Use entities in native_emitter.dart

pkg/compiler/lib/src/js_backend/backend.dart

 // Copyright (c) 2012, 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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 768 matching lines @@
    * Returns `true` if [member] is called from a subclass via `super`.
    */
   bool isAliasedSuperMember(FunctionElement member) {
     return aliasedSuperMembers.contains(member);
   }
 
   /// Returns `true` if [element] is part of JsInterop.
   @override
   bool isJsInterop(Element element) => nativeData.isJsInterop(element);
 
+  /// Returns `true` if [element] is a JsInterop class.
+  bool isJsInteropClass(ClassElement element) => isJsInterop(element);
+
+  /// Returns `true` if [element] is a JsInterop method.
+  bool isJsInteropMethod(MethodElement element) => isJsInterop(element);
+
   /// Whether [element] corresponds to a native JavaScript construct either
   /// through the native mechanism (`@Native(...)` or the `native` pseudo
   /// keyword) which is only allowed for internal libraries or via the typed
   /// JavaScriptInterop mechanism which is allowed for user libraries.
   @override
   bool isNative(Entity element) => nativeData.isNative(element);
 
   /// Returns the [NativeBehavior] for calling the native [method].
   native.NativeBehavior getNativeMethodBehavior(MethodElement method) {
     return nativeData.getNativeMethodBehavior(method);
@@ skipping 817 matching lines @@
     String name = getCheckedModeHelperNameInternal(type,
         typeCast: typeCast, nativeCheckOnly: nativeCheckOnly);
     if (name == null) return null;
     CheckedModeHelper helper = checkedModeHelperByName[name];
     assert(helper != null);
     return helper;
   }
 
   String getCheckedModeHelperNameInternal(ResolutionDartType type,
       {bool typeCast, bool nativeCheckOnly}) {
-    assert(type.kind != ResolutionTypeKind.TYPEDEF);
+    assert(!type.isDynamic);
+    assert(!type.isTypedef);
     if (type.isMalformed) {
       // The same error is thrown for type test and type cast of a malformed
       // type so we only need one check method.
       return 'checkMalformedType';
+    } else if (type.isVoid) {

[Siggi Cherem (dart-lang), 2017/01/20 17:00:15]

while we are here, we could clean up this function a bit by removing all the
`else`s. We could also avoid the duplication of some branches below if we define
something like:
   suffix = typeCast ? 'TypeCast' : 'TypeCheck';

I just played a bit with it, wdty?

  String getCheckedModeHelperNameInternal(ResolutionDartType type,
      {bool typeCast, bool nativeCheckOnly}) {
    assert(type.kind != ResolutionTypeKind.TYPEDEF);
    if (type.isMalformed) {
      // The same error is thrown for type test and type cast of a malformed
      // type so we only need one check method.
      return 'checkMalformedType';
    }

    if (type.isVoid) {
      assert(!typeCast); // Cannot cast to void.
      if (nativeCheckOnly) return null;
      return 'voidTypeCheck';
    }

    if (type.isTypeVariable) {
      return typeCast
          ? 'subtypeOfRuntimeTypeCast'
          : 'assertSubtypeOfRuntimeType';
    }

    if (type.isFunctionType) return null;

    Element element = type.element;
    bool nativeCheck =
        nativeCheckOnly || emitter.nativeEmitter.requiresNativeIsCheck(element);

    // TODO(13955), TODO(9731).  The test for non-primitive types should use an
    // interceptor.  The interceptor should be an argument to HTypeConversion so
    // that it can be optimized by standard interceptor optimizations.
    nativeCheck = true;

    var suffix = typeCast ? 'TypeCast' : 'TypeCheck';
    if (element == helpers.jsStringClass ||
        element == commonElements.stringClass) {
      if (nativeCheckOnly) return null;
      return 'string$suffix';
    }

    if (element == helpers.jsDoubleClass ||
        element == commonElements.doubleClass) {
      if (nativeCheckOnly) return null;
      return 'double$suffix';
    }

    if (element == helpers.jsNumberClass ||
        element == commonElements.numClass) {
      if (nativeCheckOnly) return null;
      return 'num$suffix';
    }

    if (element == helpers.jsBoolClass || element == commonElements.boolClass) {
      if (nativeCheckOnly) return null;
      return 'bool$suffix';
    }

    if (element == helpers.jsIntClass ||
        element == commonElements.intClass ||
        element == helpers.jsUInt32Class ||
        element == helpers.jsUInt31Class ||
        element == helpers.jsPositiveIntClass) {
      if (nativeCheckOnly) return null;
      return 'int$suffix';
    }

    if (commonElements.isNumberOrStringSupertype(element)) {
      return nativeCheck
          ? 'numberOrStringSuperNative$suffix'
          : 'numberOrStringSuper$suffix';
    }

    if (commonElements.isStringOnlySupertype(element)) {
      return nativeCheck ? 'stringSuperNative$suffix' : 'stringSuper$suffix';
    }

    if ((element == commonElements.listClass ||
            element == helpers.jsArrayClass) &&
        type.treatAsRaw) {
      if (nativeCheckOnly) return null;
      return 'list$suffix';
    }

    if (commonElements.isListSupertype(element)) {
      return nativeCheck ? 'listSuperNative$suffix' : 'listSuper$suffix';
    }

    if (type.isInterfaceType && !type.treatAsRaw) {
      return typeCast ? 'subtypeCast' : 'assertSubtype';
    }

    // TODO(karlklose): can we get rid of this branch when we use
    // interceptors?
    return nativeCheck ? 'intercepted$suffix' : 'property$suffix';
  }

[Johnni Winther, 2017/01/23 10:00:09]

I like it; it's much more readable. I've merge it with my change and put the
last todo into a then branch.

+      assert(!typeCast); // Cannot cast to void.
+      if (nativeCheckOnly) return null;
+      return 'voidTypeCheck';
+    } else if (type.isTypeVariable) {
+      return typeCast
+          ? 'subtypeOfRuntimeTypeCast'
+          : 'assertSubtypeOfRuntimeType';
+    } else if (type.isFunctionType) {
+      return null;
     }
-    Element element = type.element;
+    assert(invariant(NO_LOCATION_SPANNABLE, type.isInterfaceType,
+        message: "Unexpected type: $type (${type.kind})"));
+    ClassElement element = type.element;
     bool nativeCheck =
         nativeCheckOnly || emitter.nativeEmitter.requiresNativeIsCheck(element);
 
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
     // that it can be optimized by standard interceptor optimizations.
     nativeCheck = true;
 
-    if (type.isVoid) {
-      assert(!typeCast); // Cannot cast to void.
-      if (nativeCheckOnly) return null;
-      return 'voidTypeCheck';
-    } else if (element == helpers.jsStringClass ||
+    if (element == helpers.jsStringClass ||
         element == commonElements.stringClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'stringTypeCast' : 'stringTypeCheck';
     } else if (element == helpers.jsDoubleClass ||
         element == commonElements.doubleClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'doubleTypeCast' : 'doubleTypeCheck';
     } else if (element == helpers.jsNumberClass ||
         element == commonElements.numClass) {
       if (nativeCheckOnly) return null;
@@ skipping 26 matching lines @@
             : 'stringSuperNativeTypeCheck';
       } else {
         return typeCast ? 'stringSuperTypeCast' : 'stringSuperTypeCheck';
       }
     } else if ((element == commonElements.listClass ||
             element == helpers.jsArrayClass) &&
         type.treatAsRaw) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'listTypeCast' : 'listTypeCheck';
     } else {
       if (commonElements.isListSupertype(element)) {

[Siggi Cherem (dart-lang), 2017/01/20 17:00:15]

if we don't remove the elses, we should at least remove the nesting here and
below in 1716

[Johnni Winther, 2017/01/23 10:00:09]

Acknowledged.

         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
         } else {
           return typeCast ? 'listSuperTypeCast' : 'listSuperTypeCheck';
         }
       } else {
         if (type.isInterfaceType && !type.treatAsRaw) {
           return typeCast ? 'subtypeCast' : 'assertSubtype';
-        } else if (type.isTypeVariable) {
-          return typeCast
-              ? 'subtypeOfRuntimeTypeCast'
-              : 'assertSubtypeOfRuntimeType';
-        } else if (type.isFunctionType) {
-          return null;
         } else {
           if (nativeCheck) {
             // TODO(karlklose): can we get rid of this branch when we use
             // interceptors?
             return typeCast ? 'interceptedTypeCast' : 'interceptedTypeCheck';
           } else {
             return typeCast ? 'propertyTypeCast' : 'propertyTypeCheck';
           }
         }
       }
@@ skipping 1336 matching lines @@
     if (type is ResolutionFunctionType) {
       registerBackendImpact(transformed, impacts.functionTypeCheck);
     }
     if (type.element != null && backend.isNative(type.element)) {
       registerBackendImpact(transformed, impacts.nativeTypeCheck);
     }
   }
 
   void onIsCheckForCodegen(
       ResolutionDartType type, TransformedWorldImpact transformed) {
+    if (type.isDynamic) return;
     type = type.unaliased;
     registerBackendImpact(transformed, impacts.typeCheck);
 
     bool inCheckedMode = backend.compiler.options.enableTypeAssertions;
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (inCheckedMode) {
       // All helpers are added to resolution queue in enqueueHelpers. These
       // calls to [enqueue] with the resolution enqueuer serve as assertions
       // that the helper was in fact added.
@@ skipping 211 matching lines @@
   @override
   bool isNativeClass(ClassElement element) {
     return helpers.backend.isNative(element);
   }
 
   @override
   bool isNativeMember(MemberElement element) {
     return helpers.backend.isNative(element);
   }
 }