dart2js: store call stubs in the model.

pkg/compiler/lib/src/js_emitter/program_builder.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.program_builder;
 
 import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
 
 import '../common.dart';
 import '../js/js.dart' as js;
 
 import '../js_backend/js_backend.dart' show
     Namer,
     JavaScriptBackend,
     JavaScriptConstantCompiler;
 
-import 'js_emitter.dart' as emitterTask show
+import 'js_emitter.dart' show
+    ClassStubGenerator,
     CodeEmitterTask,
-    Emitter,
     InterceptorStubGenerator,
     TypeTestGenerator,
     TypeTestProperties;
 
 import '../universe/universe.dart' show Universe;
 import '../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 
 part 'registry.dart';
 
 class ProgramBuilder {
   final Compiler _compiler;
   final Namer namer;
-  final emitterTask.CodeEmitterTask _task;
+  final CodeEmitterTask _task;
 
   final Registry _registry;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
   ProgramBuilder(Compiler compiler,
                  this.namer,
                  this._task)
       : this._compiler = compiler,
@@ skipping 215 matching lines @@
     List<Field> staticFieldsForReflection = _buildFields(library, visitStatics);
 
     return new Library(library, uri, statics, classes,
                        staticFieldsForReflection);
   }
 
   Class _buildClass(ClassElement element) {
     bool onlyForRti = _task.typeTestRegistry.rtiNeededClasses.contains(element);
 
     List<Method> methods = [];
+    List<StubMethod> callStubs = <StubMethod>[];
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(element, member.isDeclaration));
       assert(invariant(element, element == enclosing));
 
       if (Elements.isNonAbstractInstanceMember(member)) {
         js.Expression code = backend.generatedCode[member];
         // TODO(kasperl): Figure out under which conditions code is null.
         if (code != null) methods.add(_buildMethod(member, code));
       }
+      if (member.isGetter || member.isField) {
+        Set<Selector> selectors =
+            _compiler.codegenWorld.invokedNames[member.name];
+        if (selectors != null && !selectors.isEmpty) {
+          ClassStubGenerator generator =
+              new ClassStubGenerator(_compiler, namer, backend);
+          Map<String, js.Expression> callStubsForMember =
+              generator.generateCallStubsForGetter(member, selectors);
+          callStubsForMember.forEach((String name, js.Expression code) {
+            callStubs.add(_buildStubMethod(name, code, element: member));
+          });
+        }
+      }
     }
 
     ClassElement implementation = element.implementation;
 
     // MixinApplications run through the members of their mixin. Here, we are
     // only interested in direct members.
-    if (!element.isMixinApplication) {
+    if (!onlyForRti && !element.isMixinApplication) {
       implementation.forEachMember(visitMember, includeBackendMembers: true);
     }
 
     List<Field> instanceFields =
         onlyForRti ? const <Field>[] : _buildFields(element, false);
     List<Field> staticFieldsForReflection =
         onlyForRti ? const <Field>[] : _buildFields(element, true);
 
-    emitterTask.TypeTestGenerator generator =
-        new emitterTask.TypeTestGenerator(_compiler, _task, namer);
-    emitterTask.TypeTestProperties typeTests =
+    TypeTestGenerator generator =
+        new TypeTestGenerator(_compiler, _task, namer);
+    TypeTestProperties typeTests =
         generator.generateIsTests(
             element,
             storeFunctionTypeInMetadata: _storeFunctionTypesInMetadata);
 
     List<StubMethod> isChecks = <StubMethod>[];
     typeTests.properties.forEach((String name, js.Node code) {
       isChecks.add(_buildStubMethod(name, code));
     });
 
     String name = namer.getNameOfClass(element);
     String holderName = namer.globalObjectFor(element);
     Holder holder = _registry.registerHolder(holderName);
     bool isInstantiated =
         _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication && !onlyForRti) {
       assert(!element.isNative);
       assert(methods.isEmpty);
 
       result = new MixinApplication(element,
                                     name, holder,
                                     instanceFields,
                                     staticFieldsForReflection,
+                                    callStubs,
                                     isChecks,
                                     typeTests.functionTypeIndex,
                                     isDirectlyInstantiated: isInstantiated,
                                     onlyForRti: onlyForRti);
     } else {
       result = new Class(element,
                          name, holder, methods, instanceFields,
                          staticFieldsForReflection,
+                         callStubs,
                          isChecks,
                          typeTests.functionTypeIndex,
                          isDirectlyInstantiated: isInstantiated,
                          onlyForRti: onlyForRti,
                          isNative: element.isNative);
     }
     _classes[element] = result;
     return result;
   }
 
   Method _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
     // TODO(floitsch): compute `needsTearOff`.
     return new Method(element, name, code, needsTearOff: false);
   }
 
-  Method _buildStubMethod(String name, js.Expression code) {
+  /// Builds a stub method.
+  ///
+  /// Stub methods may have an element that can be used for code-size
+  /// attribution.
+  Method _buildStubMethod(String name, js.Expression code,
+                          {Element element}) {
     // TODO(floitsch): compute `needsTearOff`.
-    return new StubMethod(name, code, needsTearOff: false);
+    return new StubMethod(name, code, needsTearOff: false, element: element);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (Set<ClassElement> classes in specializedGetInterceptors.values) {
       for (ClassElement element in classes) {
         Class cls = _classes[element];
         if (cls != null) cls.isEager = true;
       }
     }
   }
 
   Iterable<StaticMethod> _generateGetInterceptorMethods() {
-    emitterTask.InterceptorStubGenerator stubGenerator =
-        new emitterTask.InterceptorStubGenerator(_compiler, namer, backend);
+    InterceptorStubGenerator stubGenerator =
+        new InterceptorStubGenerator(_compiler, namer, backend);
 
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     Holder holder = _registry.registerHolder(holderName);
 
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     List<String> names = specializedGetInterceptors.keys.toList()..sort();
     return names.map((String name) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
@@ skipping 42 matching lines @@
 
       fields.add(new Field(field, name, accessorName,
                            getterFlags, setterFlags,
                            needsCheckedSetter));
     });
 
     return fields;
   }
 
   Iterable<StaticMethod> _generateOneShotInterceptors() {
-    emitterTask.InterceptorStubGenerator stubGenerator =
-        new emitterTask.InterceptorStubGenerator(_compiler, namer, backend);
+    InterceptorStubGenerator stubGenerator =
+        new InterceptorStubGenerator(_compiler, namer, backend);
 
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     Holder holder = _registry.registerHolder(holderName);
 
     List<String> names = backend.oneShotInterceptors.keys.toList()..sort();
     return names.map((String name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code, needsTearOff: false);
     });
   }
@@ skipping 18 matching lines @@
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }