[RFC] Associate AST nodes with HIstructions when building HGraph.

lib/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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
 
 
   CodeBuffer buildJavaScriptFunction(FunctionElement element,
                                      String parameters,
-                                     String body) {
+                                     CodeBuffer body) {
     String extraSpace = "";
     // Members are emitted inside a JavaScript object literal. To line up the
     // indentation we want the closing curly brace to be indented by one space.
     // Example:
     // defineClass("A", "B", ... , {
     //  foo$1: function(..) {
     //  },  /* <========== indent by 1. */
     //  bar$2: function(..) {
     //  },  /* <========== indent by 1. */
     //
@@ skipping 23 matching lines @@
       Map<Element, String> parameterNames = getParameterNames(work);
       parameterNames.forEach((element, name) {
         compiler.enqueuer.codegen.addToWorkList(element);
       });
       String parameters = Strings.join(parameterNames.getValues(), ', ');
       SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
-      String code;
+      CodeBuffer code;
       if (element.isInstanceMember()
           && element.enclosingElement.isClass()
           && element.enclosingElement.isNative()
           && native.isOverriddenMethod(
               element, element.enclosingElement, 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();
         native.generateMethodWithPrototypeCheckForElement(
             compiler, buffer, element, '${codegen.buffer}', parameters);
-        code = buffer.toString();
+        code = new CodeBuffer();
+        code.add(buffer);
       } else {
-        code = codegen.buffer.toString();
+        code = codegen.buffer;
       }
       return buildJavaScriptFunction(element, parameters, code);
     });
   }
 
   CodeBuffer generateBailoutMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen-bailout", graph);
 
       Map<Element, String> parameterNames = getParameterNames(work);
       String parameters = Strings.join(parameterNames.getValues(), ', ');
       SsaUnoptimizedCodeGenerator codegen = new SsaUnoptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
-      String body = '${codegen.setup}${codegen.buffer}';
+      CodeBuffer code = new CodeBuffer();
+      code.add(codegen.setup);
+      code.add(codegen.buffer);
       return buildJavaScriptFunction(
-          work.element, codegen.newParameters.toString(), body);
+          work.element, codegen.newParameters.toString(), code);
     });
   }
 
   Map<Element, String> getParameterNames(WorkItem work) {
     Map<Element, String> parameterNames = new LinkedHashMap<Element, String>();
     FunctionElement function = work.element;
 
     // The dom/html libraries have inline JS code that reference
     // parameter names directly. Long-term such code will be rejected.
     // Now, just don't mangle the parameter name.
@@ skipping 544 matching lines @@
       HCheck check = argument;
       use(check.checkedInput, expectedPrecedenceForArgument);
     } else {
       buffer.add(variableNames.getName(argument));
     }
   }
 
   visit(HInstruction node, int expectedPrecedenceForNode) {
     int oldPrecedence = this.expectedPrecedence;
     this.expectedPrecedence = expectedPrecedenceForNode;
+    if (node.sourcePosition !== null) {
+      buffer.setSourceLocation(work.element, node.sourcePosition);
+    }
     node.accept(this);
     this.expectedPrecedence = oldPrecedence;
   }
 
   void continueAsBreak(LabelElement target) {
     addIndented("break ");
     writeContinueLabel(target);
     buffer.add(";\n");
   }
 
@@ skipping 2468 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }