Towards compiling Hello World!

pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart

 // Copyright (c) 2015, 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.parameter_stub_generator;
 
 import '../closure.dart' show ClosureClassElement;
 import '../common.dart';
 import '../common_elements.dart';
 import '../constants/values.dart';
-import '../elements/elements.dart'
-    show
-        ClassElement,
-        FunctionElement,
-        FunctionSignature,
-        MethodElement,
-        ParameterElement;
 import '../elements/entities.dart';
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
-import '../js_backend/constant_handler_javascript.dart'
-    show JavaScriptConstantCompiler;
 import '../js_backend/namer.dart' show Namer;
 import '../js_backend/native_data.dart';
 import '../js_backend/interceptor_data.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart'
     show CodegenWorldBuilder, SelectorConstraints;
 import '../world.dart' show ClosedWorld;
 
 import 'model.dart';
 
 import 'code_emitter_task.dart' show CodeEmitterTask, Emitter;
 
 class ParameterStubGenerator {
   static final Set<Selector> emptySelectorSet = new Set<Selector>();
 
   final CommonElements _commonElements;
   final CodeEmitterTask _emitterTask;
-  final JavaScriptConstantCompiler _constants;
   final Namer _namer;
   final NativeData _nativeData;
   final InterceptorData _interceptorData;
   final CodegenWorldBuilder _codegenWorldBuilder;
   final ClosedWorld _closedWorld;
 
   ParameterStubGenerator(
       this._commonElements,
       this._emitterTask,
-      this._constants,
       this._namer,
       this._nativeData,
       this._interceptorData,
       this._codegenWorldBuilder,
       this._closedWorld);
 
   Emitter get _emitter => _emitterTask.emitter;
 
-  bool needsSuperGetter(FunctionElement element) =>
+  bool needsSuperGetter(FunctionEntity element) =>
       _codegenWorldBuilder.methodsNeedingSuperGetter.contains(element);
 
   /**
    * Generates stubs to handle invocation of methods with optional
    * arguments.
    *
    * A method like `foo([x])` may be invoked by the following
    * calls: `foo(), foo(1), foo(x: 1)`. This method generates the stub for the
    * given [selector] and returns the generated [ParameterStubMethod].
    *
    * Returns null if no stub is needed.
    *
    * Members may be invoked in two ways: directly, or through a closure. In the
    * latter case the caller invokes the closure's `call` method. This method
    * accepts two selectors. The returned stub method has the corresponding
    * name [ParameterStubMethod.name] and [ParameterStubMethod.callName] set if
    * the input selector is non-null (and the member needs a stub).
    */
   ParameterStubMethod generateParameterStub(
-      MethodElement member, Selector selector, Selector callSelector) {
+      FunctionEntity member, Selector selector, Selector callSelector) {
     CallStructure callStructure = selector.callStructure;
-    FunctionSignature parameters = member.functionSignature;
+    ParameterStructure parameterStructure = member.parameterStructure;
     int positionalArgumentCount = callStructure.positionalArgumentCount;
-    if (positionalArgumentCount == parameters.parameterCount) {
+    if (positionalArgumentCount == parameterStructure.totalParameters) {
       assert(callStructure.isUnnamed);
       return null;
     }
-    if (parameters.optionalParametersAreNamed &&
-        callStructure.namedArgumentCount == parameters.optionalParameterCount) {
+    if (parameterStructure.namedParameters.isNotEmpty &&
+        callStructure.namedArgumentCount ==
+            parameterStructure.namedParameters.length) {
       // If the selector has the same number of named arguments as the element,
       // we don't need to add a stub. The call site will hit the method
       // directly.
       return null;
     }
+
     List<String> names = callStructure.getOrderedNamedArguments();
 
     bool isInterceptedMethod = _interceptorData.isInterceptedMethod(member);
 
     // If the method is intercepted, we need to also pass the actual receiver.
     int extraArgumentCount = isInterceptedMethod ? 1 : 0;
     // Use '$receiver' to avoid clashes with other parameter names. Using
     // '$receiver' works because namer.safeVariableName used for getting
     // parameter names never returns a name beginning with a single '$'.
     String receiverArgumentName = r'$receiver';
 
     // The parameters that this stub takes.
     List<jsAst.Parameter> parametersBuffer =
         new List<jsAst.Parameter>(selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
     List<jsAst.Expression> argumentsBuffer = new List<jsAst.Expression>(
-        parameters.parameterCount + extraArgumentCount);
+        parameterStructure.totalParameters + extraArgumentCount);
 
     int count = 0;
     if (isInterceptedMethod) {
       count++;
       parametersBuffer[0] = new jsAst.Parameter(receiverArgumentName);
       argumentsBuffer[0] = js('#', receiverArgumentName);
     }
 
     int optionalParameterStart = positionalArgumentCount + extraArgumentCount;
     // Includes extra receiver argument when using interceptor convention
     int indexOfLastOptionalArgumentInParameters = optionalParameterStart - 1;
 
-    parameters.orderedForEachParameter((_element) {
-      ParameterElement element = _element;
-      String jsName = _namer.safeVariableName(element.name);
+    _codegenWorldBuilder.forEachParameter(member,
+        (_, String name, ConstantValue value) {
+      String jsName = _namer.safeVariableName(name);
       assert(jsName != receiverArgumentName);
       if (count < optionalParameterStart) {
         parametersBuffer[count] = new jsAst.Parameter(jsName);
         argumentsBuffer[count] = js('#', jsName);
       } else {
-        int index = names.indexOf(element.name);
+        int index = names.indexOf(name);
         if (index != -1) {
           indexOfLastOptionalArgumentInParameters = count;
           // The order of the named arguments is not the same as the
           // one in the real method (which is in Dart source order).
           argumentsBuffer[count] = js('#', jsName);
           parametersBuffer[optionalParameterStart + index] =
               new jsAst.Parameter(jsName);
         } else {
-          ConstantValue value = _constants.getConstantValue(element.constant);
           if (value == null) {
             argumentsBuffer[count] =
                 _emitter.constantReference(new NullConstantValue());
           } else {
             if (!value.isNull) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
             argumentsBuffer[count] = _emitter.constantReference(value);
           }
         }
       }
       count++;
     });
 
     var body; // List or jsAst.Statement.
     if (_nativeData.hasFixedBackendName(member)) {
       body = _emitterTask.nativeEmitter.generateParameterStubStatements(
           member,
           isInterceptedMethod,
           _namer.invocationName(selector),
           parametersBuffer,
           argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else if (member.isInstanceMember) {
       if (needsSuperGetter(member)) {
-        ClassElement superClass = member.enclosingClass;
+        ClassEntity superClass = member.enclosingClass;
         jsAst.Name methodName = _namer.instanceMethodName(member);
         // When redirecting, we must ensure that we don't end up in a subclass.
         // We thus can't just invoke `this.foo$1.call(filledInArguments)`.
         // Instead we need to call the statically resolved target.
         //   `<class>.prototype.bar$1.call(this, argument0, ...)`.
         body = js.statement('return #.#.call(this, #);', [
           _emitterTask.prototypeAccess(superClass, hasBeenInstantiated: true),
           methodName,
           argumentsBuffer
         ]);
@@ skipping 137 matching lines @@
             generateParameterStub(member, selector, null);
         if (stub != null) {
           stubs.add(stub);
         }
       }
     }
 
     return stubs;
   }
 }