It's alive!

pkg/compiler/lib/src/js_emitter/program_builder/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 'dart:io';
 import 'dart:convert' show JSON;
 
 import '../../closure.dart' show ClosureTask, ClosureFieldElement;
@@ skipping 135 matching lines @@
       this._namer,
       this._task,
       this._closedWorld,
       Set<ClassEntity> rtiNeededClasses,
       this._mainFunction,
       {bool isMockCompilation})
       : this._isMockCompilation = isMockCompilation,
         this.collector = new Collector(
             _options,
             _commonElements,
+            _elementEnvironment,
             _deferredLoadTask,
             _worldBuilder,
             _namer,
             _task.emitter,
             _constantHandler,
             _nativeData,
             _interceptorData,
             _oneShotInterceptorData,
             _mirrorsData,
             _closedWorld,
@@ skipping 462 matching lines @@
               }
             }
           });
         }
       }
     });
   }
 
   // Note that a library-element may have multiple [Library]s, if it is split
   // into multiple output units.
-  Library _buildLibrary(LibraryElement library, List<ClassEntity> classElements,
+  Library _buildLibrary(LibraryEntity library, List<ClassEntity> classElements,
       List<MemberEntity> memberElements) {
     String uri = library.canonicalUri.toString();
 
     List<StaticMethod> statics = memberElements
-        .where((e) => e is MethodElement)
+        .where((e) => !e.isField)
         .map(_buildStaticMethod)
         .toList();
 
     if (library == _commonElements.interceptorsLibrary) {
       statics.addAll(_generateGetInterceptorMethods());
       statics.addAll(_generateOneShotInterceptors());
     }
 
     List<Class> classes = classElements
-        .map((ClassElement classElement) => _classes[classElement])
+        .map((ClassEntity classElement) => _classes[classElement])
         .where((Class cls) =>
             !cls.isNative || !_unneededNativeClasses.contains(cls))
         .toList(growable: false);
 
     bool visitStatics = true;
     List<Field> staticFieldsForReflection =
-        _buildFields(library, visitStatics: visitStatics);
+        _buildFields(library: library, visitStatics: visitStatics);
 
     return new Library(
         library, uri, statics, classes, staticFieldsForReflection);
   }
 
   bool _isSoftDeferred(ClassElement element) {
     return _notSoftDeferred != null && !_notSoftDeferred.contains(element);
   }
 
   Class _buildClass(ClassElement element) {
@@ skipping 73 matching lines @@
     ClassElement implementation = element.implementation;
 
     // MixinApplications run through the members of their mixin. Here, we are
     // only interested in direct members.
     if (!onlyForRti && !element.isMixinApplication) {
       implementation.forEachMember(visitMember, includeBackendMembers: true);
     }
     bool isInterceptedClass = _interceptorData.isInterceptedClass(element);
     List<Field> instanceFields = onlyForRti
         ? const <Field>[]
-        : _buildFields(element,
-            visitStatics: false, isHolderInterceptedClass: isInterceptedClass);
+        : _buildFields(
+            cls: element,
+            visitStatics: false,
+            isHolderInterceptedClass: isInterceptedClass);
     List<Field> staticFieldsForReflection = onlyForRti
         ? const <Field>[]
-        : _buildFields(element,
-            visitStatics: true, isHolderInterceptedClass: isInterceptedClass);
+        : _buildFields(
+            cls: element,
+            visitStatics: true,
+            isHolderInterceptedClass: isInterceptedClass);
 
     TypeTestProperties typeTests = runtimeTypeGenerator.generateIsTests(element,
         storeFunctionTypeInMetadata: _storeFunctionTypesInMetadata);
 
     List<StubMethod> checkedSetters = <StubMethod>[];
     List<StubMethod> isChecks = <StubMethod>[];
     if (_nativeData.isJsInteropClass(element)) {
       typeTests.properties.forEach((js.Name name, js.Node code) {
         _classes[_commonElements.jsInterceptorClass]
             .isChecks
@@ skipping 60 matching lines @@
           hasRtiField: hasRtiField,
           onlyForRti: onlyForRti,
           isNative: _nativeData.isNativeClass(element),
           isClosureBaseClass: isClosureBaseClass,
           isSoftDeferred: _isSoftDeferred(element));
     }
     _classes[element] = result;
     return result;
   }
 
-  bool _methodNeedsStubs(FunctionElement method) {
-    return !method.functionSignature.optionalParameters.isEmpty;
+  bool _methodNeedsStubs(FunctionEntity method) {
+    return method.parameterStructure.optionalParameters != 0;
   }
 
-  bool _methodCanBeReflected(MethodElement method) {
+  bool _methodCanBeReflected(FunctionEntity method) {
     return _mirrorsData.isMemberAccessibleByReflection(method);
   }
 
-  bool _methodCanBeApplied(FunctionElement method) {
+  bool _methodCanBeApplied(FunctionEntity method) {
     return _backendUsage.isFunctionApplyUsed &&
         _closedWorld.getMightBePassedToApply(method);
   }
 
   /* Map | List */ _computeParameterDefaultValues(FunctionSignature signature) {
     var /* Map | List */ optionalParameterDefaultValues;
     if (signature.optionalParametersAreNamed) {
       optionalParameterDefaultValues = new Map<String, ConstantValue>();
       signature.forEachOptionalParameter((ParameterElement parameter) {
         ConstantValue def =
@@ skipping 93 matching lines @@
         isClosureCallMethod: isClosureCallMethod,
         aliasName: aliasName,
         canBeApplied: canBeApplied,
         canBeReflected: canBeReflected,
         requiredParameterCount: requiredParameterCount,
         optionalParameterDefaultValues: optionalParameterDefaultValues,
         functionType: functionType);
   }
 
   js.Expression _generateFunctionType(
-      ResolutionDartType type, OutputUnit outputUnit) {
+      ResolutionFunctionType type, OutputUnit outputUnit) {
     if (type.containsTypeVariables) {
       js.Expression thisAccess = js.js(r'this.$receiver');
       return _rtiEncoder.getSignatureEncoding(_task.emitter, type, thisAccess);
     } else {
       return _task.metadataCollector.reifyTypeForOutputUnit(type, outputUnit);
     }
   }
 
   List<ParameterStubMethod> _generateParameterStubs(
-      MethodElement element, bool canTearOff) {
+      FunctionEntity element, bool canTearOff) {
     if (!_methodNeedsStubs(element)) return const <ParameterStubMethod>[];
 
     ParameterStubGenerator generator = new ParameterStubGenerator(
         _commonElements,
         _task,
         _constantHandler,
         _namer,
         _nativeData,
         _interceptorData,
         _worldBuilder,
@@ skipping 47 matching lines @@
     Iterable<js.Name> names =
         _oneShotInterceptorData.specializedGetInterceptorNames;
     return names.map((js.Name name) {
       Set<ClassEntity> classes =
           _oneShotInterceptorData.getSpecializedGetInterceptorsFor(name);
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
-  List<Field> _buildFields(Element holder,
-      {bool visitStatics, bool isHolderInterceptedClass: false}) {
+  List<Field> _buildFields(
+      {bool visitStatics: false,
+      bool isHolderInterceptedClass: false,
+      LibraryEntity library,
+      ClassEntity cls}) {
     List<Field> fields = <Field>[];
-    new FieldVisitor(_options, _worldBuilder, _nativeData, _mirrorsData, _namer,
-            _closedWorld)
-        .visitFields(holder, visitStatics, (FieldElement field,
-            js.Name name,
-            js.Name accessorName,
-            bool needsGetter,
-            bool needsSetter,
-            bool needsCheckedSetter) {
+
+    void visitField(FieldElement field, js.Name name, js.Name accessorName,
+        bool needsGetter, bool needsSetter, bool needsCheckedSetter) {
       assert(field.isDeclaration, failedAt(field));
 
       int getterFlags = 0;
       if (needsGetter) {
         if (visitStatics ||
             !_interceptorData.fieldHasInterceptedGetter(field)) {
           getterFlags = 1;
         } else {
           getterFlags += 2;
           // TODO(sra): 'isInterceptedClass' might not be the correct test
@@ skipping 13 matching lines @@
         } else {
           setterFlags += 2;
           if (!isHolderInterceptedClass) {
             setterFlags += 1;
           }
         }
       }
 
       fields.add(new Field(field, name, accessorName, getterFlags, setterFlags,
           needsCheckedSetter));
-    });
+    }
+
+    FieldVisitor visitor = new FieldVisitor(_options, _elementEnvironment,
+        _worldBuilder, _nativeData, _mirrorsData, _namer, _closedWorld);
+    visitor.visitFields(visitField,
+        visitStatics: visitStatics, library: library, cls: cls);
 
     return fields;
   }
 
   Iterable<StaticStubMethod> _generateOneShotInterceptors() {
     InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
         _options,
         _commonElements,
         _task,
         _nativeCodegenEnqueuer,
@@ skipping 10 matching lines @@
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
     List<js.Name> names = _oneShotInterceptorData.oneShotInterceptorNames;
     return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
-  StaticDartMethod _buildStaticMethod(MethodElement element) {
+  StaticDartMethod _buildStaticMethod(FunctionEntity element) {
     js.Name name = _namer.methodPropertyName(element);
     String holder = _namer.globalObjectForMember(element);
     js.Expression code = _generatedCode[element];
 
-    bool isApplyTarget = !element.isConstructor && !element.isAccessor;
+    bool isApplyTarget =
+        !element.isConstructor && !element.isGetter && !element.isSetter;
     bool canBeApplied = _methodCanBeApplied(element);
     bool canBeReflected = _methodCanBeReflected(element);
 
     bool needsTearOff = isApplyTarget &&
         (canBeReflected ||
             _worldBuilder.staticFunctionsNeedingGetter.contains(element));
 
     js.Name tearOffName =
         needsTearOff ? _namer.staticClosureName(element) : null;
 
     js.Name callName = null;
     if (needsTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
       callName = _namer.invocationName(callSelector);
     }
     js.Expression functionType;
-    ResolutionDartType type = element.type;
+    DartType type = _elementEnvironment.getFunctionType(element);
     if (needsTearOff || canBeReflected) {
-      OutputUnit outputUnit = _deferredLoadTask.outputUnitForElement(element);
+      OutputUnit outputUnit = _deferredLoadTask.outputUnitForMember(element);
       functionType = _generateFunctionType(type, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
     if (canBeApplied || canBeReflected) {
-      FunctionSignature signature = element.functionSignature;
+      // TODO(johnniwinther): Support entities;
+      MethodElement method = element;
+      FunctionSignature signature = method.functionSignature;
       requiredParameterCount = signature.requiredParameterCount;
       optionalParameterDefaultValues =
           _computeParameterDefaultValues(signature);
     }
 
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static method.
     return new StaticDartMethod(element, name, _registry.registerHolder(holder),
         code, _generateParameterStubs(element, needsTearOff), callName,
         needsTearOff: needsTearOff,
@@ skipping 19 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }