Emit classes using ASTs

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 24 matching lines @@
           sourceFile, expression.getEndToken());
     }
     return result;
   }
 
   CodeBuffer prettyPrint(js.Node node) {
     var code = js.prettyPrint(node, compiler, allowVariableMinification: true);
     return code;
   }
 
-  CodeBuffer generateCode(WorkItem work, HGraph graph) {
+  js.Expression generateCode(WorkItem work, HGraph graph) {
     if (work.element.isField()) {
       return generateLazyInitializer(work, graph);
     } else {
       return generateMethod(work, graph);
     }
   }
 
-  CodeBuffer generateLazyInitializer(work, graph) {
+  js.Expression generateLazyInitializer(work, graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       SsaOptimizedCodeGenerator codegen =
           new SsaOptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
-      js.Block body = codegen.body;
-      js.Fun fun = new js.Fun(codegen.parameters, body);
-      return prettyPrint(fun);
+      return new js.Fun(codegen.parameters, codegen.body);
     });
   }
 
-  CodeBuffer generateMethod(WorkItem work, HGraph graph) {
+  js.Expression generateMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       SsaOptimizedCodeGenerator codegen =
           new SsaOptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
       js.Block body;
       ClassElement enclosingClass = element.getEnclosingClass();
 
       if (element.isInstanceMember()
           && enclosingClass.isNative()
           && native.isOverriddenMethod(
               element, enclosingClass, nativeEmitter)) {
         // Record that this method is overridden. In case of optional
         // arguments, the emitter will generate stubs to handle them,
         // and needs to know if the method is overridden.
         nativeEmitter.overriddenMethods.add(element);
         StringBuffer buffer = new StringBuffer();
         body =
             nativeEmitter.generateMethodBodyWithPrototypeCheckForElement(
                 element, codegen.body, codegen.parameters);
       } else {
         body = codegen.body;
       }
 
-      js.Fun fun = buildJavaScriptFunction(element, codegen.parameters, body);
-      return prettyPrint(fun);
+      return buildJavaScriptFunction(element, codegen.parameters, body);
     });
   }
 
-  CodeBuffer generateBailoutMethod(WorkItem work, HGraph graph) {
+  js.Expression generateBailoutMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen-bailout", graph);
 
       SsaUnoptimizedCodeGenerator codegen =
           new SsaUnoptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
 
       js.Block body = new js.Block(<js.Statement>[]);
       if (codegen.setup != null) body.statements.add(codegen.setup);
       body.statements.add(codegen.body);
       js.Fun fun =
           buildJavaScriptFunction(work.element, codegen.newParameters, body);
-      return prettyPrint(fun);
+      return fun;
     });
   }
 }
 
 // Stop-gap until the core classes have such a class.
 class OrderedSet<T> {
   final LinkedHashMap<T, bool> map = new LinkedHashMap<T, bool>();
 
   void add(T x) {
     if (!map.containsKey(x)) {
@@ skipping 2065 matching lines @@
     use(input);
     js.Expression right = pop();
     // TODO(4984): Deal with infinity and -0.0.
     push(new js.LiteralExpression.withData('Math.floor(#) === #',
                                            <js.Expression>[left, right]));
   }
 
   void checkTypeOf(HInstruction input, String cmp, String typeName) {
     use(input);
     js.Expression typeOf = new js.Prefix("typeof", pop());
-    push(new js.Binary(cmp, typeOf, new js.LiteralString("'$typeName'")));
+    push(new js.Binary(cmp, typeOf, js.string(typeName)));
   }
 
   void checkNum(HInstruction input, String cmp)
       => checkTypeOf(input, cmp, 'number');
 
   void checkDouble(HInstruction input, String cmp)  => checkNum(input, cmp);
 
   void checkString(HInstruction input, String cmp)
       => checkTypeOf(input, cmp, 'string');
 
@@ skipping 287 matching lines @@
       List<js.Expression> arguments = <js.Expression>[];
       use(node.checkedInput);
       arguments.add(pop());
       int parameterCount =
           helperElement.computeSignature(compiler).parameterCount;
       if (parameterCount == 2) {
         // 2 arguments implies that the method is either [propertyTypeCheck]
         // or [propertyTypeCast].
         assert(!type.isMalformed);
         String additionalArgument = backend.namer.operatorIs(element);
-        arguments.add(new js.LiteralString("'$additionalArgument'"));
+        arguments.add(js.string(additionalArgument));
       } else if (parameterCount == 3) {
         // 3 arguments implies that the method is [malformedTypeCheck].
         assert(type.isMalformed);
         String reasons = fetchReasonsFromMalformedType(type);
-        arguments.add(new js.LiteralString("'$type'"));
+        arguments.add(js.string('$type'));
         // TODO(johnniwinther): Handle escaping correctly.
-        arguments.add(new js.LiteralString("'$reasons'"));
+        arguments.add(js.string(reasons));
       } else {
         assert(!type.isMalformed);
       }
       String helperName = backend.namer.isolateAccess(helperElement);
       push(new js.Call(new js.VariableUse(helperName), arguments));
     } else {
       use(node.checkedInput);
     }
   }
 }
@@ skipping 521 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }