Use entities in interceptor_stub_generator.

pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart

 // Copyright (c) 2014, 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.js_emitter.interceptor_stub_generator;
 
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
-import '../elements/resolution_types.dart' show ResolutionInterfaceType;
-import '../elements/elements.dart' show ClassElement, Element;
+import '../elements/entities.dart';
+import '../elements/types.dart' show InterfaceType;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart'
     show
         CustomElementsAnalysis,
         JavaScriptBackend,
         JavaScriptConstantCompiler,
         Namer;
 import '../universe/selector.dart' show Selector;
 import '../world.dart' show ClosedWorld;
 
 import 'code_emitter_task.dart' show Emitter;
 
 class InterceptorStubGenerator {
   final Compiler compiler;
   final Namer namer;
   final JavaScriptBackend backend;
   final ClosedWorld closedWorld;
 
   InterceptorStubGenerator(
       this.compiler, this.namer, this.backend, this.closedWorld);
 
   Emitter get emitter => backend.emitter.emitter;
 
   BackendHelpers get helpers => backend.helpers;
 
-  jsAst.Expression generateGetInterceptorMethod(Set<ClassElement> classes) {
-    jsAst.Expression interceptorFor(ClassElement cls) {
+  jsAst.Expression generateGetInterceptorMethod(Set<ClassEntity> classes) {
+    jsAst.Expression interceptorFor(ClassEntity cls) {
       return backend.emitter.interceptorPrototypeAccess(cls);
     }
 
     /**
      * Build a JavaScrit AST node for doing a type check on
      * [cls]. [cls] must be a non-native interceptor class.
      */
-    jsAst.Statement buildInterceptorCheck(ClassElement cls) {
+    jsAst.Statement buildInterceptorCheck(ClassEntity cls) {
       jsAst.Expression condition;
       assert(backend.isInterceptorClass(cls));
       if (cls == helpers.jsBoolClass) {
         condition = js('(typeof receiver) == "boolean"');
       } else if (cls == helpers.jsIntClass ||
           cls == helpers.jsDoubleClass ||
           cls == helpers.jsNumberClass) {
         throw 'internal error';
       } else if (cls == helpers.jsArrayClass ||
           cls == helpers.jsMutableArrayClass ||
@@ skipping 14 matching lines @@
     bool hasBool = false;
     bool hasDouble = false;
     bool hasInt = false;
     bool hasNull = false;
     bool hasNumber = false;
     bool hasString = false;
     bool hasNative = false;
     bool anyNativeClasses =
         compiler.enqueuer.codegen.nativeEnqueuer.hasInstantiatedNativeClasses;
 
-    for (ClassElement cls in classes) {
+    for (ClassEntity cls in classes) {
       if (cls == helpers.jsArrayClass ||
           cls == helpers.jsMutableArrayClass ||
           cls == helpers.jsFixedArrayClass ||
           cls == helpers.jsExtendableArrayClass)
         hasArray = true;
       else if (cls == helpers.jsBoolClass)
         hasBool = true;
       else if (cls == helpers.jsDoubleClass)
         hasDouble = true;
       else if (cls == helpers.jsIntClass)
@@ skipping 86 matching lines @@
           return #(receiver);
       }''',
           [
             interceptorFor(helpers.jsJavaScriptFunctionClass),
             backend.emitter
                 .constructorAccess(compiler.commonElements.objectClass),
             backend.emitter
                 .staticFunctionAccess(helpers.getNativeInterceptorMethod)
           ]));
     } else {
-      ClassElement jsUnknown = helpers.jsUnknownJavaScriptObjectClass;
+      ClassEntity jsUnknown = helpers.jsUnknownJavaScriptObjectClass;
       if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
           .contains(jsUnknown)) {
         statements.add(js.statement('if (!(receiver instanceof #)) return #;', [
           backend.emitter
               .constructorAccess(compiler.commonElements.objectClass),
           interceptorFor(jsUnknown)
         ]));
       }
 
       statements.add(js.statement('return receiver'));
     }
 
     return js('''function(receiver) { #; }''', new jsAst.Block(statements));
   }
 
   // Returns a statement that takes care of performance critical
   // common case for a one-shot interceptor, or null if there is no
   // fast path.
   jsAst.Statement _fastPathForOneShotInterceptor(
-      Selector selector, Set<ClassElement> classes) {
+      Selector selector, Set<ClassEntity> classes) {
     if (selector.isOperator) {
       String name = selector.name;
       if (name == '==') {
         return js.statement('''{
           if (receiver == null) return a0 == null;
           if (typeof receiver != "object")
             return a0 != null && receiver === a0;
         }''');
       }
       if (!classes.contains(helpers.jsIntClass) &&
@@ skipping 111 matching lines @@
               return receiver[a0] = a1;
           ''',
             typeCheck);
       }
     }
     return null;
   }
 
   jsAst.Expression generateOneShotInterceptor(jsAst.Name name) {
     Selector selector = backend.oneShotInterceptors[name];
-    Set<ClassElement> classes = backend.getInterceptedClassesOn(selector.name);
+    Set<ClassEntity> classes = backend.getInterceptedClassesOn(selector.name);
     jsAst.Name getInterceptorName = namer.nameForGetInterceptor(classes);
 
     List<String> parameterNames = <String>[];
     parameterNames.add('receiver');
 
     if (selector.isSetter) {
       parameterNames.add('value');
     } else {
       for (int i = 0; i < selector.argumentCount; i++) {
         parameterNames.add('a$i');
@@ skipping 21 matching lines @@
     // TODO(sra): Perhaps inject a constant instead?
     CustomElementsAnalysis analysis = backend.customElementsAnalysis;
     if (!analysis.needsTable) return null;
 
     List<jsAst.Expression> elements = <jsAst.Expression>[];
     JavaScriptConstantCompiler handler = backend.constants;
     List<ConstantValue> constants =
         handler.getConstantsForEmission(emitter.compareConstants);
     for (ConstantValue constant in constants) {
       if (constant is TypeConstantValue &&
-          constant.representedType is ResolutionInterfaceType) {
-        ResolutionInterfaceType type = constant.representedType;
-        Element element = type.element;
-        if (element is ClassElement) {

[Siggi Cherem (dart-lang), 2017/01/19 16:48:22]

Just to double-check, this `if` was practically innecessary? (all
TypeConstantValue are defined in terms of a class element, correct?) What if the
type is unresolved?

[Johnni Winther, 2017/01/20 07:57:04]

All [InterfaceType]s point to a [ClassEntity], if it was unresolved it would
have resulted in a [MalformedType].

-          ClassElement classElement = element;
-          if (!analysis.needsClass(classElement)) continue;
+          constant.representedType is InterfaceType) {
+        InterfaceType type = constant.representedType;
+        ClassEntity classElement = type.element;
+        if (!analysis.needsClass(classElement)) continue;
 
-          elements.add(emitter.constantReference(constant));
-          elements.add(backend.emitter.interceptorClassAccess(classElement));
+        elements.add(emitter.constantReference(constant));
+        elements.add(backend.emitter.interceptorClassAccess(classElement));
 
-          // Create JavaScript Object map for by-name lookup of generative
-          // constructors.  For example, the class A has three generative
-          // constructors
-          //
-          //     class A {
-          //       A() {}
-          //       A.foo() {}
-          //       A.bar() {}
-          //     }
-          //
-          // Which are described by the map
-          //
-          //     {"": A.A$, "foo": A.A$foo, "bar": A.A$bar}
-          //
-          // We expect most of the time the map will be a singleton.
-          var properties = [];
-          for (Element member in analysis.constructors(classElement)) {
-            properties.add(new jsAst.Property(js.string(member.name),
-                backend.emitter.staticFunctionAccess(member)));
-          }
+        // Create JavaScript Object map for by-name lookup of generative
+        // constructors.  For example, the class A has three generative
+        // constructors
+        //
+        //     class A {
+        //       A() {}
+        //       A.foo() {}
+        //       A.bar() {}
+        //     }
+        //
+        // Which are described by the map
+        //
+        //     {"": A.A$, "foo": A.A$foo, "bar": A.A$bar}
+        //
+        // We expect most of the time the map will be a singleton.
+        var properties = [];
+        for (FunctionEntity member in analysis.constructors(classElement)) {
+          properties.add(new jsAst.Property(js.string(member.name),
+              backend.emitter.staticFunctionAccess(member)));
+        }
 
-          var map = new jsAst.ObjectInitializer(properties);
-          elements.add(map);
-        }
+        var map = new jsAst.ObjectInitializer(properties);
+        elements.add(map);
       }
     }
 
     return new jsAst.ArrayInitializer(elements);
   }
 }