Use entities in class_stub_generator.

pkg/compiler/lib/src/js_emitter/class_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.class_stub_generator;
 
-import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../compiler.dart' show Compiler;
-import '../elements/elements.dart'
-    show
-    ClassElement,
-    Element;
+import '../elements/entities.dart';
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
-import '../js_backend/js_backend.dart'
-    show
-    JavaScriptBackend,
-    Namer;
+import '../js_backend/js_backend.dart' show JavaScriptBackend, Namer;

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

I see that you are fixing format here after the other CL, so if it creates
churn/conflict, no worries about submitting the other one without dartfmt and
making the formatting changes separately

 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart'
     show CodegenWorldBuilder, SelectorConstraints;
 import '../world.dart' show ClosedWorld;
 
 import 'model.dart';
 
 class ClassStubGenerator {
   final Namer namer;
   final JavaScriptBackend backend;
   final CodegenWorldBuilder worldBuilder;
   final ClosedWorld closedWorld;
   final bool enableMinification;
 
   ClassStubGenerator(
       this.namer, this.backend, this.worldBuilder, this.closedWorld,
       {this.enableMinification});
 
-  jsAst.Expression generateClassConstructor(ClassElement classElement,
-      Iterable<jsAst.Name> fields, bool hasRtiField) {
+  jsAst.Expression generateClassConstructor(
+      ClassEntity classElement, Iterable<jsAst.Name> fields, bool hasRtiField) {
     // TODO(sra): Implement placeholders in VariableDeclaration position:
     //
     //     String constructorName = namer.getNameOfClass(classElement);
     //     return js.statement('function #(#) { #; }',
     //        [ constructorName, fields,
     //            fields.map(
     //                (name) => js('this.# = #', [name, name]))]));
     var typeParameters = const <jsAst.Parameter>[];
     var typeInits = const <jsAst.Expression>[];
     if (hasRtiField) {
       String parameterName = r'$ti';
       typeParameters = parameterName;
       typeInits = js('this.# = #', [namer.rtiFieldName, parameterName]);
     }
     return js('function(#, #) { #; #; this.#();}', [
       fields,
       typeParameters,
       fields.map((name) => js('this.# = #', [name, name])),
       typeInits,
       namer.deferredAction
     ]);
   }
 
-  jsAst.Expression generateGetter(Element member, jsAst.Name fieldName) {
-    ClassElement cls = member.enclosingClass;
+  jsAst.Expression generateGetter(MemberEntity member, jsAst.Name fieldName) {
+    ClassEntity cls = member.enclosingClass;
     String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
     return js('function(#) { return #.# }', [args, receiver, fieldName]);
   }
 
-  jsAst.Expression generateSetter(Element member, jsAst.Name fieldName) {
-    ClassElement cls = member.enclosingClass;
+  jsAst.Expression generateSetter(MemberEntity member, jsAst.Name fieldName) {
+    ClassEntity cls = member.enclosingClass;
     String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
     // TODO(floitsch): remove 'return'?
     return js(
         'function(#, v) { return #.# = v; }', [args, receiver, fieldName]);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   Map<jsAst.Name, jsAst.Expression> generateCallStubsForGetter(
-      Element member, Map<Selector, SelectorConstraints> selectors) {
-    assert(invariant(member, member.isDeclaration));
-
+      MemberEntity member, Map<Selector, SelectorConstraints> selectors) {
     // If the method is intercepted, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
     bool isInterceptedMethod = backend.isInterceptedMethod(member);
     bool isInterceptorClass = backend.isInterceptorClass(member.enclosingClass);
 
     const String receiverArgumentName = r'$receiver';
 
     jsAst.Expression buildGetter() {
       jsAst.Expression receiver =
           js(isInterceptorClass ? receiverArgumentName : 'this');
@@ skipping 132 matching lines @@
 ///    Each function must have the `$callName` property set.
 ///   * `reflectionInfo`: contains reflective information, and the function
 ///    type. TODO(floitsch): point to where this is specified.
 ///   * `isStatic`.
 ///   * `name`.
 ///   * `isIntercepted.
 List<jsAst.Statement> buildTearOffCode(JavaScriptBackend backend) {
   Namer namer = backend.namer;
   Compiler compiler = backend.compiler;
 
-  Element closureFromTearOff = backend.helpers.closureFromTearOff;
+  FunctionEntity closureFromTearOff = backend.helpers.closureFromTearOff;
   jsAst.Expression tearOffAccessExpression;
   jsAst.Expression tearOffGlobalObjectString;
   jsAst.Expression tearOffGlobalObject;
   if (closureFromTearOff != null) {
     tearOffAccessExpression =
         backend.emitter.staticFunctionAccess(closureFromTearOff);
     tearOffGlobalObject =
-        js.stringPart(namer.globalObjectFor(closureFromTearOff));
+        js.stringPart(namer.globalObjectForMethod(closureFromTearOff));
     tearOffGlobalObjectString =
-        js.string(namer.globalObjectFor(closureFromTearOff));
+        js.string(namer.globalObjectForMethod(closureFromTearOff));
   } else {
     // Default values for mocked-up test libraries.
     tearOffAccessExpression =
         js(r'''function() { throw "Helper 'closureFromTearOff' missing." }''');
     tearOffGlobalObjectString = js.string('MissingHelperFunction');
     tearOffGlobalObject = js(
         r'''(function() { throw "Helper 'closureFromTearOff' missing." })()''');
   }
 
   jsAst.Statement tearOffGetter;
@@ skipping 53 matching lines @@
               if (cache === void 0) cache = #tearOff(
                   this, funcs, reflectionInfo, true, [], name).prototype;
               return cache;
             }
           : tearOffGetter(funcs, reflectionInfo, name, isIntercepted);
     }''',
       {'tearOff': tearOffAccessExpression});
 
   return <jsAst.Statement>[tearOffGetter, tearOff];
 }