Revert "Use js.ExpressionStatement to avoid $N."

dart/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 1306 matching lines @@
 
     emitClassConstructor(classElement, builder);
     emitSuper(superName, builder);
     emitClassFields(classElement, builder,
                     superClass: superName, classIsNative: false);
     emitClassGettersSetters(classElement, builder);
     emitInstanceMembers(classElement, builder);
 
     jsAst.Expression init =
         js[classesCollector][className].assign(builder.toObjectInitializer());
-    buffer.add(jsAst.prettyPrint(init.toStatement(), compiler));
-    buffer.add(n);
+    buffer.add(jsAst.prettyPrint(init, compiler));
+    buffer.add('$N$n');
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
   int _selectorRank(Selector selector) {
     int arity = selector.argumentCount * 3;
     if (selector.isGetter()) return arity + 2;
     if (selector.isSetter()) return arity + 1;
     return arity;
   }
@@ skipping 258 matching lines @@
       // Reset the map.
       buffer.add("$classesCollector$_=$_{}$N");
     }
   }
 
   void emitStaticFunction(CodeBuffer buffer,
                           String name,
                           jsAst.Expression functionExpression) {
     jsAst.Expression assignment =
         js[isolateProperties][name].assign(functionExpression);
-    buffer.add(jsAst.prettyPrint(assignment.toStatement(), compiler));
-    buffer.add(n);
+    buffer.add(jsAst.prettyPrint(assignment, compiler));
+    buffer.add('$N$n');
   }
 
   void emitStaticFunctions(CodeBuffer eagerBuffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         backend.generatedBailoutCode.keys
@@ skipping 37 matching lines @@
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName$_=$_$fieldAccess$N");
 
       addParameterStubs(callElement, (String name, jsAst.Expression value) {
         jsAst.Expression assignment =
             js[isolateProperties][staticName][name].assign(value);
         buffer.add(
             jsAst.prettyPrint(assignment.toStatement(), compiler));
+        buffer.add('$N');
       });
 
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName$_=$_"$staticName"$N');
       getTypedefChecksOn(element.computeType(compiler)).forEach(
         (Element typedef) {
           String operator = namer.operatorIs(typedef);
           buffer.add('$fieldAccess.$operator$_=${_}true$N');
@@ skipping 121 matching lines @@
 
       addParameterStubs(callElement, boundClosureBuilder.addProperty);
       typedefChecks.forEach((Element typedef) {
         String operator = namer.operatorIs(typedef);
         boundClosureBuilder.addProperty(operator, new jsAst.LiteralBool(true));
       });
 
       jsAst.Expression init =
           js[classesCollector][mangledName].assign(
               boundClosureBuilder.toObjectInitializer());
-      boundClosureBuffer.add(jsAst.prettyPrint(init.toStatement(), compiler));
+      boundClosureBuffer.add(jsAst.prettyPrint(init, compiler));
+      boundClosureBuffer.add("$N");
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (canBeShared) {
         cache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
@@ skipping 87 matching lines @@
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         jsAst.Expression init =
           js[isolateProperties][namer.getName(element)].assign(
               constantEmitter.referenceInInitializationContext(initialValue));
-        buffer.add(jsAst.prettyPrint(init.toStatement(), compiler));
+        buffer.add(jsAst.prettyPrint(init, compiler));
+        buffer.add('$N');
       });
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
@@ skipping 10 matching lines @@
         arguments.add(js[isolateProperties]);
         arguments.add(js.string(element.name.slowToString()));
         arguments.add(js.string(namer.getName(element)));
         arguments.add(js.string(namer.getLazyInitializerName(element)));
         arguments.add(code);
         jsAst.Expression getter = buildLazyInitializedGetter(element);
         if (getter != null) {
           arguments.add(getter);
         }
         jsAst.Expression init = js[lazyInitializerName](arguments);
-        buffer.add(jsAst.prettyPrint(init.toStatement(), compiler));
+        buffer.add(jsAst.prettyPrint(init, compiler));
+        buffer.add("$N");
       }
     }
   }
 
   jsAst.Expression buildLazyInitializedGetter(VariableElement element) {
     // Nothing to do, the 'lazy' function will create the getter.
     return null;
   }
 
   void emitCompileTimeConstants(CodeBuffer buffer) {
@@ skipping 10 matching lines @@
       // The name is null when the constant is already a JS constant.
       // TODO(floitsch): every constant should be registered, so that we can
       // share the ones that take up too much space (like some strings).
       if (name == null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
         emitMakeConstantList(buffer);
       }
       jsAst.Expression init = js[isolateProperties][name].assign(
           constantInitializerExpression(constant));
-      buffer.add(jsAst.prettyPrint(init.toStatement(), compiler));
+      buffer.add(jsAst.prettyPrint(init, compiler));
+      buffer.add('$N');
     }
   }
 
   void emitMakeConstantList(CodeBuffer buffer) {
     buffer.add(namer.isolateName);
     buffer.add(r'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
@@ skipping 320 matching lines @@
       block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
       block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
     block.statements.add(js.return_(js[objectName]['prototype']));
 
     buffer.add(jsAst.prettyPrint(
-        js[isolateProperties][key].assign(
-            js.fun(['receiver'], block)).toStatement(),
+        js[isolateProperties][key].assign(js.fun(['receiver'], block)),
         compiler));
+    buffer.add(N);
   }
 
   /**
    * Emit all versions of the [:getInterceptor:] method.
    */
   void emitGetInterceptorMethods(CodeBuffer buffer) {
     // If no class needs to be intercepted, just return.
     if (backend.objectInterceptorClass == null) return;
     String objectName = namer.isolateAccess(backend.objectInterceptorClass);
     var specializedGetInterceptors = backend.specializedGetInterceptors;
@@ skipping 210 matching lines @@
       String invocationName = backend.namer.invocationName(selector);
       body.add(js.return_(
           js[isolateProperties][getInterceptorName]('receiver')[invocationName](
               arguments)));
 
       jsAst.Fun function = js.fun(parameters, body);
 
       jsAst.PropertyAccess property =
           js[isolateProperties][name];
 
-      buffer.add(jsAst.prettyPrint(property.assign(function).toStatement(),
-                                   compiler));
+      buffer.add(jsAst.prettyPrint(property.assign(function), compiler));
+      buffer.add(N);
     }
   }
 
   void emitInitFunction(CodeBuffer buffer) {
     jsAst.Fun fun = js.fun([], [
       js['$isolateProperties = {}'],
     ]
     ..addAll(buildDefineClassAndFinishClassFunctionsIfNecessary())
     ..addAll(buildLazyInitializerFunctionIfNecessary())
     ..addAll(buildFinishIsolateConstructor())
@@ skipping 138 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // 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].
 """;