dart2js: Add elements to the emitter's 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';
@@ skipping 159 matching lines @@
         .toList(growable: false);
   }
 
   StaticField _buildStaticField(Element element) {
     JavaScriptConstantCompiler handler = backend.constants;
     ConstantValue initialValue = handler.getInitialValueFor(element).value;
     js.Expression code = _task.emitter.constantReference(initialValue);
     String name = namer.getNameOfGlobalField(element);
     bool isFinal = false;
     bool isLazy = false;
-    return new StaticField(name, _registry.registerHolder(r'$'), code,
+    return new StaticField(element,
+                           name, _registry.registerHolder(r'$'), code,
                            isFinal, isLazy);
   }
 
   List<StaticField> _buildStaticLazilyInitializedFields(Fragment fragment) {
     // TODO(floitsch): lazy fields should just be in their respective
     // libraries.
     if (fragment != _registry.mainFragment) return const <StaticField>[];
 
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     return Elements.sortedByPosition(lazyFields)
         .map(_buildLazyField)
         .where((field) => field != null)  // Happens when the field was unused.
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(Element element) {
     JavaScriptConstantCompiler handler = backend.constants;
     js.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
     String name = namer.getNameOfGlobalField(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
-    return new StaticField(name, _registry.registerHolder(r'$'), code,
+    return new StaticField(element,
+                           name, _registry.registerHolder(r'$'), code,
                            isFinal, isLazy);
   }
 
   List<Library> _buildLibraries(Fragment fragment) {
     List<Library> libraries = new List<Library>(fragment.length);
     int count = 0;
     fragment.forEach((LibraryElement library, List<Element> elements) {
       libraries[count++] = _buildLibrary(library, elements);
     });
     return libraries;
@@ skipping 15 matching lines @@
     if (library == backend.interceptorsLibrary) {
       statics.addAll(_generateGetInterceptorMethods());
       statics.addAll(_generateOneShotInterceptors());
     }
 
     List<Class> classes = elements
         .where((e) => e is ClassElement)
         .map(_buildClass)
         .toList(growable: false);
 
-    return new Library(uri, statics, classes);
+    return new Library(library, uri, statics, classes);
   }
 
   Class _buildClass(ClassElement element) {
     List<Method> methods = [];
     List<InstanceField> fields = [];
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(element, member.isDeclaration));
       assert(invariant(element, element == enclosing));
 
@@ skipping 22 matching lines @@
     // At this point a mixin application must not have any methods or fields.
     // Type-tests might be added to mixin applications, too.
     assert(!element.isMixinApplication || methods.isEmpty);
     assert(!element.isMixinApplication || fields.isEmpty);
 
     // TODO(floitsch): we should not add the code here, but have a list of
     // is/as classes in the Class object.
     // The individual emitters should then call the type test generator to
     // generate the code.
     typeTests.properties.forEach((String name, js.Node code) {
-      methods.add(_buildMethodWithName(name, code));
+      methods.add(_buildStubMethod(name, code));
     });
 
     String name = namer.getNameOfClass(element);
     String holderName = namer.globalObjectFor(element);
     Holder holder = _registry.registerHolder(holderName);
     bool onlyForRti = _task.typeTestRegistry.rtiNeededClasses.contains(element);
     bool isInstantiated =
         _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication) {
-      result = new MixinApplication(name, holder, methods, fields,
+      result = new MixinApplication(element,
+                                    name, holder, methods, fields,
                                     isDirectlyInstantiated: isInstantiated,
                                     onlyForRti: onlyForRti);
     } else {
-      result = new Class(name, holder, methods, fields,
+      result = new Class(element,
+                         name, holder, methods, fields,
                          isDirectlyInstantiated: isInstantiated,
                          onlyForRti: onlyForRti);
     }
     _classes[element] = result;
     return result;
   }
 
   Method _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
-    return new Method(name, code);
+    return new Method(element, name, code);
   }
 
-  Method _buildMethodWithName(String name, js.Expression code) {
-    return new Method(name, code);
+  Method _buildStubMethod(String name, js.Expression code) {
+    return new StubMethod(name, code);
   }
 
   // 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);
 
     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);
-      return new StaticMethod(name, holder, code);
+      return new StaticStubMethod(name, holder, code);
     });
   }
 
   bool _fieldNeedsGetter(VariableElement field) {
     assert(field.isField);
     if (_fieldAccessNeverThrows(field)) return false;
     return backend.shouldRetainGetter(field)
         || _compiler.codegenWorld.hasInvokedGetter(field, _compiler.world);
   }
 
@@ skipping 36 matching lines @@
       if (isIntercepted) {
         setterFlags += 2;
         if (backend.isInterceptorClass(holder)) {
           setterFlags += 1;
         }
       } else {
         setterFlags = 1;
       }
     }
 
-    return new InstanceField(name, getterFlags, setterFlags);
+    return new InstanceField(field, name, getterFlags, setterFlags);
   }
 
   Iterable<StaticMethod> _generateOneShotInterceptors() {
     emitterTask.InterceptorStubGenerator stubGenerator =
         new emitterTask.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 StaticMethod(name, holder, code);
+      return new StaticStubMethod(name, holder, code);
     });
   }
 
   StaticMethod _buildStaticMethod(FunctionElement element) {
     String name = namer.getNameOfMember(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
-    return new StaticMethod(name, _registry.registerHolder(holder), code);
+    return new StaticMethod(element,
+                            name, _registry.registerHolder(holder), code);
   }
 
   StaticMethod _buildStaticMethodTearOff(FunctionElement element) {
     String name = namer.getStaticClosureName(element);
     String holder = namer.globalObjectFor(element);
     // TODO(kasperl): This clearly doesn't work yet.
     js.Expression code = js.string("<<unimplemented>>");
-    return new StaticMethod(name, _registry.registerHolder(holder), code);
+    return new StaticMethod(element,
+                            name, _registry.registerHolder(holder), code);
   }
 
   void _registerConstants(OutputUnit outputUnit,
                           List<ConstantValue> constantValues) {
     if (constantValues == null) return;
     for (ConstantValue constantValue in constantValues) {
       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;
     };
   }
 }