Generate parameter stubs using ASTs.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 71 matching lines @@
   }
 
   js.Expression constantReference(Constant value) {
     return constantEmitter.reference(value);
   }
 
   js.Expression constantInitializerExpression(Constant value) {
     return constantEmitter.initializationExpression(value);
   }
 
-  // Deprecated.  Remove after last use is converted to JS ASTs.
-  void writeConstantToBuffer(Constant value, CodeBuffer buffer) {
-    buffer.add(js.prettyPrint(constantReference(value), compiler));
-  }
-
   String get name => 'CodeEmitter';
 
   String get defineClassName
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName
       => '${namer.ISOLATE}.\$finishClasses';
   String get finishIsolateConstructorName
       => '${namer.ISOLATE}.\$finishIsolateConstructor';
   String get pendingClassesName
       => '${namer.ISOLATE}.\$pendingClasses';
@@ skipping 312 matching lines @@
       return;
     }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName =
         namer.instanceMethodInvocationName(member.getLibrary(), member.name,
                                            selector);
     if (alreadyGenerated.contains(invocationName)) return;
     alreadyGenerated.add(invocationName);
-    CodeBuffer buffer = new CodeBuffer();
-    buffer.add('function(');
 
     JavaScriptBackend backend = compiler.backend;
     bool isInterceptorClass =
         backend.isInterceptorClass(member.getEnclosingClass());
 
     // If the method is in an interceptor class, we need to also pass
     // the actual receiver.
     int extraArgumentCount = isInterceptorClass ? 1 : 0;
     // Use '$receiver' to avoid clashes with other parameter names. Using
     // '$receiver' works because [JsNames.getValid] used for getting parameter
     // names never returns a name beginning with a single '$'.
     String receiverArgumentName = r'$receiver';
 
     // The parameters that this stub takes.
-    List<String> parametersBuffer =
-        new List<String>(selector.argumentCount + extraArgumentCount);
+    List<js.Parameter> parametersBuffer =
+        new List<js.Parameter>(selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
-    List<String> argumentsBuffer =
-        new List<String>(parameters.parameterCount + extraArgumentCount);
+    List<js.Expression> argumentsBuffer =
+        new List<js.Expression>(parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
     if (isInterceptorClass) {
       count++;
-      parametersBuffer[0] = receiverArgumentName;
-      argumentsBuffer[0] = receiverArgumentName;
+      parametersBuffer[0] = new js.Parameter(receiverArgumentName);
+      argumentsBuffer[0] = new js.VariableUse(receiverArgumentName);
     }
 
     int indexOfLastOptionalArgumentInParameters = positionalArgumentCount - 1;
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(member);
 
     parameters.orderedForEachParameter((Element element) {
       String jsName = JsNames.getValid(element.name.slowToString());
       assert(jsName != receiverArgumentName);
       if (count < positionalArgumentCount + extraArgumentCount) {
-        parametersBuffer[count] = jsName;
-        argumentsBuffer[count] = jsName;
+        parametersBuffer[count] = new js.Parameter(jsName);
+        argumentsBuffer[count] = new js.VariableUse(jsName);
       } else {
         int index = names.indexOf(element.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] = jsName;
-          parametersBuffer[selector.positionalArgumentCount + index] = jsName;
+          argumentsBuffer[count] = new js.VariableUse(jsName);
+          parametersBuffer[selector.positionalArgumentCount + index] =
+              new js.Parameter(jsName);
         // Note that [elements] may be null for a synthetized [member].

[floitsch, 2012/11/29 16:49:05]

synthesized

[sra1, 2012/11/29 20:39:10]

Done.

         } else if (elements != null && elements.isParameterChecked(element)) {
-          CodeBuffer argumentBuffer = new CodeBuffer();
-          writeConstantToBuffer(SentinelConstant.SENTINEL, argumentBuffer);
-          argumentsBuffer[count] = argumentBuffer.toString();
+          argumentsBuffer[count] = constantReference(SentinelConstant.SENTINEL);
         } else {
           Constant value = handler.initialVariableValues[element];
           if (value == null) {
-            argumentsBuffer[count] = NullConstant.JsNull;
+            argumentsBuffer[count] = constantReference(new NullConstant());
           } else {
             if (!value.isNull()) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
-            CodeBuffer argumentBuffer = new CodeBuffer();
-            writeConstantToBuffer(value, argumentBuffer);
-            argumentsBuffer[count] = argumentBuffer.toString();
+            argumentsBuffer[count] = constantReference(value);
           }
         }
       }
       count++;
     });
-    String parametersString = Strings.join(parametersBuffer, ",");
-    buffer.add('$parametersString) {\n');
 
+    List<js.Statement> body;
     if (member.isNative()) {
-      nativeEmitter.generateParameterStub(
-          member, invocationName, parametersString, argumentsBuffer,
-          indexOfLastOptionalArgumentInParameters, buffer);
+      body = nativeEmitter.generateParameterStub(
+          member, invocationName, parametersBuffer, argumentsBuffer,
+          indexOfLastOptionalArgumentInParameters);
     } else {
-      String arguments = Strings.join(argumentsBuffer, ",");
-      buffer.add('  return this.${namer.getName(member)}($arguments)');
+      body = <js.Statement>[
+          new js.Return(
+              new js.VariableUse('this')
+                  .dot(namer.getName(member))
+                  .callOn(argumentsBuffer))];
     }
-    buffer.add('\n}');
+
+    js.Fun function = new js.Fun(parametersBuffer, new js.Block(body));
+
+    CodeBuffer buffer = new CodeBuffer();
+    buffer.add(js.prettyPrint(function, compiler));
     defineInstanceMember(invocationName, buffer);
   }
 
   void addParameterStubs(FunctionElement member,
                          DefineMemberFunction defineInstanceMember) {
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
     //
     // We may have multiple ways of calling foo:
@@ skipping 1297 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;