Various redemptions

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 ClosureConversionTask, ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../constants/values.dart'
     show ConstantValue, InterceptorConstantValue;
 import '../../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../../elements/elements.dart'
-    show
-        ClassElement,
-        FieldElement,
-        FunctionSignature,
-        LibraryElement,
-        MemberElement,
-        MethodElement,
-        ParameterElement;
+    show ClassElement, FieldElement, LibraryElement, MethodElement;
 import '../../elements/entities.dart';
-import '../../elements/resolution_types.dart' show ResolutionDartType;
 import '../../elements/types.dart';
 import '../../js/js.dart' as js;
 import '../../js_backend/backend.dart' show SuperMemberData;
 import '../../js_backend/backend_usage.dart';
 import '../../js_backend/constant_handler_javascript.dart'
     show JavaScriptConstantCompiler;
 import '../../js_backend/custom_elements_analysis.dart';
 import '../../js_backend/namer.dart' show Namer, StringBackedName;
 import '../../js_backend/native_data.dart';
 import '../../js_backend/interceptor_data.dart';
@@ skipping 147 matching lines @@
   final Map<js.Name, String> _symbolsMap = <js.Name, String>{};
 
   Set<Class> _unneededNativeClasses;
 
   /// Classes that have been allocated during a profile run.
   ///
   /// These classes should not be soft-deferred.
   ///
   /// Also contains classes that are not tracked by the profile run (like
   /// interceptors, ...).
-  Set<ClassElement> _notSoftDeferred;
+  Set<ClassEntity> _notSoftDeferred;
 
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
     collector.collect();
     _initializeSoftDeferredMap();
 
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _deferredLoadTask.allOutputUnits.forEach(_registry.registerOutputUnit);
@@ skipping 113 matching lines @@
         _reporter.log("Profile file does not exist: $allocatedClassesPath");
         return;
       }
       if (file.lengthSync() == 0) {
         _reporter.log("Profile information (allocated classes) is empty.");
         return;
       }
 
       String data = new File(allocatedClassesPath).readAsStringSync();
       Set<String> allocatedClassesKeys = JSON.decode(data).keys.toSet();
-      Set<ClassElement> allocatedClasses = new Set<ClassElement>();
+      Set<ClassEntity> allocatedClasses = new Set<ClassEntity>();
 
       // Collects all super and mixin classes of a class.
-      void collect(ClassElement element) {
+      void collect(ClassEntity element) {
         allocatedClasses.add(element);
-        if (element.isMixinApplication) {
+        if (_elementEnvironment.isMixinApplication(element)) {
           collect(_elementEnvironment.getEffectiveMixinClass(element));
         }
-        if (element.superclass != null) {
-          collect(element.superclass);
+        ClassEntity superclass = _elementEnvironment.getSuperClass(element);
+        if (superclass != null) {
+          collect(superclass);
         }
       }
 
       // For every known class, see if it was allocated in the profile. If yes,
       // collect its dependencies (supers and mixins) and mark them as
       // not-soft-deferrable.
       collector.outputClassLists.forEach((_, List<ClassEntity> elements) {
-        for (ClassElement element in elements) {
+        for (ClassEntity element in elements) {
           // TODO(29574): share the encoding of the element with the code
           // that emits the profile-run.
           var key = "${element.library.canonicalUri}:${element.name}";
           if (allocatedClassesKeys.contains(key) ||
               _nativeData.isJsInteropClass(element) ||
               blackList.contains(element.library.canonicalUri.toString())) {
             collect(element);
           }
         }
       });
@@ skipping 198 matching lines @@
               }
             }
 
             // Generating stubs for direct calls and stubs for call-through
             // of getters that happen to be functions.
             bool isFunctionLike = false;
             FunctionType functionType = null;
 
             if (member.isFunction) {
               MethodElement fn = member;
-              functionType = fn.type;
+              functionType = _elementEnvironment.getFunctionType(fn);
             } else if (member.isGetter) {
               if (_options.trustTypeAnnotations) {
                 DartType returnType =
                     _elementEnvironment.getFunctionType(member).returnType;
                 if (returnType.isFunctionType) {
                   functionType = returnType;
                 } else if (returnType.treatAsDynamic ||
                     _types.isSubtype(
                         returnType,
                         // ignore: UNNECESSARY_CAST
@@ skipping 203 matching lines @@
     if (_nativeData.isJsInteropClass(cls)) {
       typeTests.forEachProperty(_sorter, (js.Name name, js.Node code) {
         _classes[_commonElements.jsInterceptorClass]
             .isChecks
             .add(_buildStubMethod(name, code));
       });
     } else {
       for (Field field in instanceFields) {
         if (field.needsCheckedSetter) {
           assert(!field.needsUncheckedSetter);
-          FieldElement element = field.element;
+          FieldEntity element = field.element;
           js.Expression code = _generatedCode[element];
           assert(code != null);
           js.Name name = _namer.deriveSetterName(field.accessorName);
           checkedSetters.add(_buildStubMethod(name, code, element: element));
         }
       }
 
       typeTests.forEachProperty(_sorter, (js.Name name, js.Node code) {
         isChecks.add(_buildStubMethod(name, code));
       });
@@ skipping 56 matching lines @@
 
   bool _methodCanBeReflected(FunctionEntity method) {
     return _mirrorsData.isMemberAccessibleByReflection(method);
   }
 
   bool _methodCanBeApplied(FunctionEntity method) {
     return _backendUsage.isFunctionApplyUsed &&
         _closedWorld.getMightBePassedToApply(method);
   }
 
-  /* Map | List */ _computeParameterDefaultValues(FunctionSignature signature) {
+  /* Map | List */ _computeParameterDefaultValues(FunctionEntity method) {
     var /* Map | List */ optionalParameterDefaultValues;
-    if (signature.optionalParametersAreNamed) {
+    ParameterStructure parameterStructure = method.parameterStructure;
+    if (parameterStructure.namedParameters.isNotEmpty) {
       optionalParameterDefaultValues = new Map<String, ConstantValue>();
-      signature.forEachOptionalParameter((_parameter) {
-        ParameterElement parameter = _parameter;
-        ConstantValue def =
-            _constantHandler.getConstantValue(parameter.constant);
-        optionalParameterDefaultValues[parameter.name] = def;
+      _worldBuilder.forEachParameter(method,
+          (DartType type, String name, ConstantValue defaultValue) {
+        if (parameterStructure.namedParameters.contains(name)) {
+          assert(defaultValue != null);
+          optionalParameterDefaultValues[name] = defaultValue;
+        }
       });
     } else {
       optionalParameterDefaultValues = <ConstantValue>[];
-      signature.forEachOptionalParameter((_parameter) {
-        ParameterElement parameter = _parameter;
-        ConstantValue def =
-            _constantHandler.getConstantValue(parameter.constant);
-        optionalParameterDefaultValues.add(def);
+      int index = 0;
+      _worldBuilder.forEachParameter(method,
+          (DartType type, String name, ConstantValue defaultValue) {
+        if (index >= parameterStructure.requiredParameters) {
+          assert(defaultValue != null);
+          optionalParameterDefaultValues.add(defaultValue);
+        }
+        index++;
       });
     }
     return optionalParameterDefaultValues;
   }
 
   DartMethod _buildMethod(FunctionEntity element) {
     assert(!(element is MethodElement && !element.isDeclaration));
     js.Name name = _namer.methodPropertyName(element);
     js.Expression code = _generatedCode[element];
 
@@ skipping 45 matching lines @@
     js.Expression functionType;
     if (canTearOff || canBeReflected) {
       OutputUnit outputUnit = _deferredLoadTask.outputUnitForMember(element);
       functionType = _generateFunctionType(memberType, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
     if (canBeApplied || canBeReflected) {
       // TODO(redemption): Handle function entities.
-      MethodElement method = element;
-      FunctionSignature signature = method.functionSignature;
-      requiredParameterCount = signature.requiredParameterCount;
-      optionalParameterDefaultValues =
-          _computeParameterDefaultValues(signature);
+      FunctionEntity method = element;
+      ParameterStructure parameterStructure = method.parameterStructure;
+      requiredParameterCount = parameterStructure.requiredParameters;
+      optionalParameterDefaultValues = _computeParameterDefaultValues(method);
     }
 
     return new InstanceMethod(element, name, code,
         _generateParameterStubs(element, canTearOff), callName,
         needsTearOff: canTearOff,
         tearOffName: tearOffName,
         isClosureCallMethod: isClosureCallMethod,
         aliasName: aliasName,
         canBeApplied: canBeApplied,
         canBeReflected: canBeReflected,
@@ skipping 25 matching lines @@
         _worldBuilder,
         _closedWorld);
     return generator.generateParameterStubs(element, canTearOff: canTearOff);
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
   Method _buildStubMethod(js.Name name, js.Expression code,
-      {MemberElement element}) {
+      {MemberEntity element}) {
     return new StubMethod(name, code, 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() {
     Iterable<js.Name> names =
         _oneShotInterceptorData.specializedGetInterceptorNames;
     for (js.Name name in names) {
@@ skipping 69 matching lines @@
           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);
+    FieldVisitor visitor = new FieldVisitor(
+        _options,
+        _elementEnvironment,
+        _commonElements,
+        _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,
@@ skipping 45 matching lines @@
     DartType type = _elementEnvironment.getFunctionType(element);
     if (needsTearOff || canBeReflected) {
       OutputUnit outputUnit = _deferredLoadTask.outputUnitForMember(element);
       functionType = _generateFunctionType(type, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
     if (canBeApplied || canBeReflected) {
       // TODO(redemption): Support entities;
-      MethodElement method = element;
-      FunctionSignature signature = method.functionSignature;
-      requiredParameterCount = signature.requiredParameterCount;
-      optionalParameterDefaultValues =
-          _computeParameterDefaultValues(signature);
+      FunctionEntity method = element;
+      ParameterStructure parameterStructure = method.parameterStructure;
+      requiredParameterCount = parameterStructure.requiredParameters;
+      optionalParameterDefaultValues = _computeParameterDefaultValues(method);
     }
 
     // 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,
         tearOffName: tearOffName,
         canBeApplied: canBeApplied,
         canBeReflected: canBeReflected,
@@ skipping 16 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }