JS templates

sdk/lib/_internal/compiler/implementation/js_backend/native_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;
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 337 matching lines @@
     // specializations.
   }
 
   void potentiallyConvertDartClosuresToJs(
       List<jsAst.Statement> statements,
       FunctionElement member,
       List<jsAst.Parameter> stubParameters) {
     FunctionSignature parameters = member.functionSignature;
     Element converter =
         compiler.findHelper('convertDartClosureToJS');
-    String closureConverter = backend.namer.isolateAccess(converter);
-    Set<String> stubParameterNames = new Set<String>.from(
-        stubParameters.map((param) => param.name));
+    jsAst.Expression closureConverter = backend.namer.elementAccess(converter);
     parameters.forEachParameter((ParameterElement parameter) {
       String name = parameter.name;
       // If [name] is not in [stubParameters], then the parameter is an optional
       // parameter that was not provided for this stub.
       for (jsAst.Parameter stubParameter in stubParameters) {
         if (stubParameter.name == name) {
           DartType type = parameter.type.unalias(compiler);
           if (type is FunctionType) {
             // The parameter type is a function type either directly or through
             // typedef(s).
             FunctionType functionType = type;
             int arity = functionType.computeArity();
             statements.add(
-                js('$name = $closureConverter($name, $arity)').toStatement());
+                js.statement('# = #(#, $arity)',
+                    [name, closureConverter, name]));
             break;
           }
         }
       }
     });
   }
 
   List<jsAst.Statement> generateParameterStubStatements(
       Element member,
       bool isInterceptedMethod,
@@ skipping 26 matching lines @@
 
     if (isInterceptedMethod) {
       receiver = argumentsBuffer[0];
       arguments = argumentsBuffer.sublist(1,
           indexOfLastOptionalArgumentInParameters + 1);
     } else {
       receiver = js('this');
       arguments = argumentsBuffer.sublist(0,
           indexOfLastOptionalArgumentInParameters + 1);
     }
-    statements.add(new jsAst.Return(receiver[target](arguments)));
+    //statements.add(new jsAst.Return(receiver[target](arguments)));

[floitsch, 2014/04/22 16:11:18]

dead code.

[sra1, 2014/04/23 02:33:50]

Done.

+    statements.add(
+        js.statement('return #.#(#)', [receiver, target, arguments]));
 
     return statements;
   }
 
   bool isSupertypeOfNativeClass(Element element) {
     if (element.isTypeVariable()) {
       compiler.internalError(element, "Is check for type variable.");
       return false;
     }
     if (element.computeType(compiler).unalias(compiler) is FunctionType) {
@@ skipping 38 matching lines @@
       // If the native emitter has been asked to take care of the
       // noSuchMethod handlers, we do that now.
       if (handleNoSuchMethod) {
         emitter.nsmEmitter.emitNoSuchMethodHandlers(addProperty);
       }
     }
 
     // If we have any properties to add to Object.prototype, we run
     // through them and add them using defineProperty.
     if (!objectProperties.isEmpty) {
-      jsAst.Expression init =
-          js.fun(['table'],
-              new jsAst.ForIn(
-                  new jsAst.VariableDeclarationList(
-                      [new jsAst.VariableInitialization(
-                          new jsAst.VariableDeclaration('key'),
-                          null)]),
-                  js('table'),
-                  new jsAst.ExpressionStatement(
-                      js('$defPropName(Object.prototype, key, table[key])'))))(
-              new jsAst.ObjectInitializer(objectProperties));
+      jsAst.Expression init = js('''
+          (function(table) {
+            for(var key in table)
+              $defPropName(Object.prototype, key, table[key]);

[floitsch, 2014/04/22 16:11:18]

We could make defPropAccess a template, and thus avoid a template that depends
on string-interpolation.

[sra1, 2014/04/23 02:33:50]

Done.

+           })(#)''',
+          new jsAst.ObjectInitializer(objectProperties));
 
       if (emitter.compiler.enableMinification) targetBuffer.add(';');
       targetBuffer.add(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetBuffer.add('\n');
     }
 
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }