Add SourceInformationFactory.

pkg/compiler/lib/src/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;
+  final SourceInformationFactory sourceInformationFactory;
 
-  SsaCodeGeneratorTask(JavaScriptBackend backend)
+  SsaCodeGeneratorTask(JavaScriptBackend backend,
+                       this.sourceInformationFactory)
       : this.backend = backend,
         super(backend.compiler);
+
   String get name => 'SSA code generator';
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
 
   js.Node attachPosition(js.Node node, AstElement element) {
     return node.withSourceInformation(
         StartEndSourceInformation.computeSourceInformation(element));
   }
 
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
     js.AsyncModifier asyncModifier = element.asyncMarker.isAsync
         ? (element.asyncMarker.isYielding
             ? const js.AsyncModifier.asyncStar()
             : const js.AsyncModifier.async())
         : (element.asyncMarker.isYielding
             ? const js.AsyncModifier.syncStar()
             : const js.AsyncModifier.sync());
 
-    return attachPosition(
-        new js.Fun(parameters, body, asyncModifier: asyncModifier), element);
+    return new js.Fun(parameters, body, asyncModifier: asyncModifier)
+        .withSourceInformation(sourceInformationFactory.forContext(element)
+            .buildDeclaration(element));
   }
 
   js.Expression generateCode(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField) {
       return generateLazyInitializer(work, graph);
     } else {
       return generateMethod(work, graph);
     }
   }
 
   js.Expression generateLazyInitializer(work, graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
+      SourceInformation sourceInformation =
+          sourceInformationFactory.forContext(work.element)
+              .buildDeclaration(work.element);
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
       codegen.visitGraph(graph);
-      return new js.Fun(codegen.parameters,
-          attachPosition(codegen.body, work.element));
+      return new js.Fun(codegen.parameters, codegen.body)
+          .withSourceInformation(sourceInformation);
     });
   }
 
   js.Expression generateMethod(CodegenWorkItem work, HGraph graph) {
     return measure(() {
       FunctionElement element = work.element;
       if (element.asyncMarker != AsyncMarker.SYNC) {
         work.registry.registerAsyncMarker(element);
       }
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
@@ skipping 65 matching lines @@
 
   HGraph currentGraph;
 
   // Records a block-information that is being handled specially.
   // Used to break bad recursion.
   HBlockInformation currentBlockInformation;
   // The subgraph is used to delimit traversal for some constructions, e.g.,
   // if branches.
   SubGraph subGraph;
 
-  SsaCodeGenerator(this.backend, CodegenWorkItem work)
+  SsaCodeGenerator(this.backend, CodegenWorkItem work,
+                   {SourceInformation sourceInformation})
     : this.work = work,
       declaredLocals = new Set<String>(),
       collectedVariableDeclarations = new Set<String>(),
       currentContainer = new js.Block.empty(),
       parameters = <js.Parameter>[],
       expressionStack = <js.Expression>[],
       oldContainerStack = <js.Block>[],
       generateAtUseSite = new Set<HInstruction>(),
       controlFlowOperators = new Set<HInstruction>(),
       breakAction = new Map<Entity, EntityAction>(),
@@ skipping 2555 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 }