Revert "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 36 matching lines @@
   String get dynamicFunctionTableName {
     Element element = compiler.findHelper('dynamicFunctionTable');
     return backend.namer.isolateAccess(element);
   }
 
   String get typeNameOfName {
     Element element = compiler.findHelper('getTypeNameOf');
     return backend.namer.isolateAccess(element);
   }
 
-  jsAst.Expression get defPropFunction {
+  String get defPropName {
     Element element = compiler.findHelper('defineProperty');
-    return backend.namer.elementAccess(element);
+    return backend.namer.isolateAccess(element);
   }
 
   String get toStringHelperName {
     Element element = compiler.findHelper('toStringForNativeObject');
     return backend.namer.isolateAccess(element);
   }
 
   String get hashCodeHelperName {
     Element element = compiler.findHelper('hashCodeForNativeObject');
     return backend.namer.isolateAccess(element);
@@ skipping 278 matching lines @@
     // specializations.
   }
 
   void potentiallyConvertDartClosuresToJs(
       List<jsAst.Statement> statements,
       FunctionElement member,
       List<jsAst.Parameter> stubParameters) {
     FunctionSignature parameters = member.functionSignature;
     Element converter =
         compiler.findHelper('convertDartClosureToJS');
-    jsAst.Expression closureConverter = backend.namer.elementAccess(converter);
+    String closureConverter = backend.namer.isolateAccess(converter);
+    Set<String> stubParameterNames = new Set<String>.from(
+        stubParameters.map((param) => param.name));
     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.statement('# = #(#, $arity)',
-                    [name, closureConverter, name]));
+                js('$name = $closureConverter($name, $arity)').toStatement());
             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(
-        js.statement('return #.#(#)', [receiver, target, arguments]));
+    statements.add(new jsAst.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(r'''
-          (function(table) {
-            for(var key in table)
-              #(Object.prototype, key, table[key]);
-           })(#)''',
-          [ defPropFunction,
-            new jsAst.ObjectInitializer(objectProperties)]);
+      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));
 
       if (emitter.compiler.enableMinification) targetBuffer.add(';');
       targetBuffer.add(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetBuffer.add('\n');
     }
 
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }