Add source information to variable declarations in CPS.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Identifiers,
@@ skipping 469 matching lines @@
         irBuilder.addPrimitive(new ir.InvokeMethodDirectly(
             instance, bodyElement, selector, bodyArguments, null));
       }
 
       // --- step 4: return the created object ----
       irBuilder.buildReturn(
           value: instance,
           sourceInformation:
           sourceInformationBuilder.buildImplicitReturn(constructor));
 
-      return irBuilder.makeFunctionDefinition();
+      return irBuilder.makeFunctionDefinition(
+          sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   /// Make a visitor suitable for translating ASTs taken from [context].
   ///
   /// Every visitor can only be applied to nodes in one context, because
   /// the [elements] field is specific to that context.
   IrBuilderVisitor makeVisitorForContext(AstElement context) {
     return new IrBuilderVisitor(
         context.resolvedAst.elements,
@@ skipping 230 matching lines @@
     // TODO(kmillikin): We should combine closure conversion and try/catch
     // variable analysis in some way.
     TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
           getClosureScopeForNode(node));
       visit(node.body);
-      return irBuilder.makeFunctionDefinition();
+      return irBuilder.makeFunctionDefinition(
+          sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
@@ skipping 22 matching lines @@
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () {
       irBuilder.buildFunctionHeader(<Local>[]);
       ir.Primitive initialValue = visit(element.initializer);
       ast.VariableDefinitions node = element.node;
       ast.SendSet sendSet = node.definitions.nodes.head;
       irBuilder.buildReturn(
           value: initialValue,
           sourceInformation:
           sourceInformationBuilder.buildReturn(sendSet.assignmentOperator));
-      return irBuilder.makeFunctionDefinition();
+      return irBuilder.makeFunctionDefinition(
+          sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   /// Builds the IR for a constant taken from a different [context].
   ///
   /// Such constants need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineConstant(AstElement context, ast.Expression exp) {
     IrBuilderVisitor visitor = makeVisitorForContext(context);
     return visitor.withBuilder(irBuilder, () => visitor.translateConstant(exp));
@@ skipping 150 matching lines @@
 
       ir.Primitive refinement = irBuilder.addPrimitive(
           new ir.Refinement(allocation, typeMaskSystem.arrayType));
 
       irBuilder.buildReturn(value: refinement,
           sourceInformation:
               sourceInformationBuilder.buildImplicitReturn(element));
     } else {
       visit(node.body);
     }
-    return irBuilder.makeFunctionDefinition();
+    return irBuilder.makeFunctionDefinition(
+        sourceInformationBuilder.buildVariableDeclaration());
   }
 
   /// Builds the IR for creating an instance of the closure class corresponding
   /// to the given nested function.
   closure.ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
     closure.ClosureClassMap innerMap =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     closure.ClosureClassElement closureClass = innerMap.closureClassElement;
     return closureClass;
   }
@@ skipping 3077 matching lines @@
     _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
       '${_backend.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
     _backend.helpers.jsJavaScriptObjectClass.thisType;
 }