Add SourceInformationFactory.

pkg/compiler/lib/src/ssa/builder.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 SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
 
-  SsaFunctionCompiler(JavaScriptBackend backend, bool generateSourceMap)
-      : generator = new SsaCodeGeneratorTask(backend),
-        builder = new SsaBuilderTask(backend, generateSourceMap),
+  SsaFunctionCompiler(JavaScriptBackend backend,
+                      SourceInformationFactory sourceInformationFactory)
+      : generator = new SsaCodeGeneratorTask(backend, sourceInformationFactory),
+        builder = new SsaBuilderTask(backend, sourceInformationFactory),
         optimizer = new SsaOptimizerTask(backend);
 
   /// Generates JavaScript code for `work.element`.
   /// Using the ssa builder, optimizer and codegenerator.
   js.Fun compile(CodegenWorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     Element element = work.element;
     js.Expression result = generator.generateCode(work, graph);
     if (element is FunctionElement) {
@@ skipping 64 matching lines @@
   final ExecutableElement executableContext;
 
   SyntheticLocal(this.name, this.executableContext);
 
   toString() => 'SyntheticLocal($name)';
 }
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
-  final bool generateSourceMap;
+  final SourceInformationFactory sourceInformationFactory;
 
   String get name => 'SSA builder';
 
-  SsaBuilderTask(JavaScriptBackend backend, this.generateSourceMap)
+  SsaBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
     : emitter = backend.emitter,
       backend = backend,
       super(backend.compiler);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       Element element = work.element.implementation;
       return compiler.withCurrentElement(element, () {
         HInstruction.idCounter = 0;
         SsaBuilder builder =
             new SsaBuilder(
-                backend, work, emitter.nativeEmitter, generateSourceMap);
+                backend, work, emitter.nativeEmitter,
+                sourceInformationFactory);
         HGraph graph;
         ElementKind kind = element.kind;
         if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
           graph = compileConstructor(builder, work);
         } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                    kind == ElementKind.FUNCTION ||
                    kind == ElementKind.GETTER ||
                    kind == ElementKind.SETTER) {
           graph = builder.buildMethod(element);
         } else if (kind == ElementKind.FIELD) {
@@ skipping 66 matching lines @@
   SsaBuilder builder;
   ClosureClassMap closureData;
   Map<TypeVariableType, TypeVariableLocal> typeVariableLocals =
       new Map<TypeVariableType, TypeVariableLocal>();
   final ExecutableElement executableContext;
 
   /// The class that defines the current type environment or null if no type
   /// variables are in scope.
   ClassElement get contextClass => executableContext.contextClass;
 
+  SourceInformationBuilder get sourceInformationBuilder {
+    return builder.sourceInformationBuilder;
+  }
+
   LocalsHandler(this.builder, this.executableContext);
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
         type = type.substByContext(
             contextClass.asInstanceOf(typeContext));
@@ skipping 774 matching lines @@
 
 /**
  * This class builds SSA nodes for functions represented in AST.
  */
 class SsaBuilder extends NewResolvedVisitor {
   final Compiler compiler;
   final JavaScriptBackend backend;
   final ConstantSystem constantSystem;
   final CodegenWorkItem work;
   final RuntimeTypes rti;
-  final bool generateSourceMap;
+  SourceInformationBuilder sourceInformationBuilder;
   bool inLazyInitializerExpression = false;
 
   /* This field is used by the native handler. */
   final NativeEmitter nativeEmitter;
 
   final HGraph graph = new HGraph();
 
   /**
    * The current block to add instructions to. Might be null, if we are
    * visiting dead code, but see [isReachable].
@@ skipping 67 matching lines @@
   /// Returns `true` if the current element is an `async` function.
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
             element.asyncMarker == AsyncMarker.ASYNC);
   }
 
   SsaBuilder(JavaScriptBackend backend,
              CodegenWorkItem work,
              this.nativeEmitter,
-             this.generateSourceMap)
+             SourceInformationFactory sourceInformationFactory)
     : this.compiler = backend.compiler,
       this.backend = backend,
       this.constantSystem = backend.constantSystem,
       this.work = work,
       this.rti = backend.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this, work.element);
     sourceElementStack.add(work.element);
+    sourceInformationBuilder =
+        sourceInformationFactory.forContext(work.element.implementation);
   }
 
   CodegenRegistry get registry => work.registry;
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
   Element get sourceElement => sourceElementStack.last;
@@ skipping 50 matching lines @@
   }
 
   void add(HInstruction instruction) {
     current.add(instruction);
   }
 
   void addWithPosition(HInstruction instruction, ast.Node node) {
     add(attachPosition(instruction, node));
   }
 
-  SourceFile currentSourceFile() {
-    return sourceElement.implementation.compilationUnit.script.file;
-  }
-
-  void checkValidSourceFileLocation(
-      SourceLocation location, SourceFile sourceFile, int offset) {
-    if (!location.isValid) {
-      throw MessageKind.INVALID_SOURCE_FILE_LOCATION.message(
-          {'offset': offset,
-           'fileName': sourceFile.filename,
-           'length': sourceFile.length});
-    }
-  }
-
   /**
    * Returns a complete argument list for a call of [function].
    */
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
     assert(invariant(function, function.isImplementation));
     assert(providedArguments != null);
@@ skipping 266 matching lines @@
   bool isCalledOnce(Element element) {
     if (!allInlinedFunctionsCalledOnce) return false;
     TypesInferrer inferrer = compiler.typesTask.typesInferrer;
     return inferrer.isCalledOnce(element);
   }
 
   inlinedFrom(Element element, f()) {
     assert(element is FunctionElement || element is VariableElement);
     return compiler.withCurrentElement(element, () {
       // The [sourceElementStack] contains declaration elements.
+      SourceInformationBuilder oldSourceInformationBuilder =
+          sourceInformationBuilder;
+      sourceInformationBuilder =
+          sourceInformationBuilder.forContext(element.implementation);
       sourceElementStack.add(element.declaration);
       var result = f();
+      sourceInformationBuilder = oldSourceInformationBuilder;
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   HInstruction handleConstantForOptionalParameter(Element parameter) {
     ConstantExpression constant =
         backend.constants.getConstantForVariable(parameter);
     assert(invariant(parameter, constant != null,
         message: 'No constant computed for $parameter'));
@@ skipping 1031 matching lines @@
           value,
           compiler.boolClass.rawType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, backend.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
-    if (generateSourceMap && node != null) {
-      target.sourceInformation = sourceInformationForBeginToken(node);
+    if (node != null) {
+      target.sourceInformation = sourceInformationBuilder.buildGeneric(node);
     }
     return target;
   }
 
-  SourceInformation sourceInformationForBeginToken(ast.Node node) {
-    return new StartEndSourceInformation(sourceFileLocationForBeginToken(node));
-  }
-
-  SourceInformation sourceInformationForBeginEndToken(ast.Node node) {
-    return new StartEndSourceInformation(
-        sourceFileLocationForBeginToken(node),
-        sourceFileLocationForEndToken(node));
-  }
-
-  SourceLocation sourceFileLocationForBeginToken(ast.Node node) =>
-      sourceFileLocationForToken(node, node.getBeginToken());
-
-  SourceLocation sourceFileLocationForEndToken(ast.Node node) =>
-      sourceFileLocationForToken(node, node.getEndToken());
-
-  SourceLocation sourceFileLocationForToken(ast.Node node, Token token) {
-    SourceFile sourceFile = currentSourceFile();
-    SourceLocation location =
-        new TokenSourceLocation(sourceFile, token, sourceElement.name);
-    checkValidSourceFileLocation(location, sourceFile, token.charOffset);
-    return location;
-  }
-
   void visit(ast.Node node) {
     if (node != null) node.accept(this);
   }
 
   visitBlock(ast.Block node) {
     assert(!isAborted());
     if (!isReachable) return;  // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
          !link.isEmpty;
          link = link.tail) {
@@ skipping 249 matching lines @@
       conditionBlock.postProcessLoopHeader();
       HLoopBlockInformation info =
           new HLoopBlockInformation(
               HLoopBlockInformation.loopType(loop),
               wrapExpressionGraph(initializerGraph),
               wrapExpressionGraph(conditionExpression),
               wrapStatementGraph(bodyGraph),
               wrapExpressionGraph(updateGraph),
               conditionBlock.loopInformation.target,
               conditionBlock.loopInformation.labels,
-              sourceInformationForBeginEndToken(loop));
+              sourceInformationBuilder.buildLoop(loop));
 
       startBlock.setBlockFlow(info, current);
       loopInfo.loopBlockInformation = info;
     } else {
       // The body of the for/while loop always aborts, so there is no back edge.
       // We turn the code into:
       // if (condition) {
       //   body;
       // } else {
       //   // We always create an empty else block to avoid critical edges.
@@ skipping 196 matching lines @@
       SubGraph bodyGraph = new SubGraph(loopEntryBlock, bodyExitBlock);
       HLoopBlockInformation loopBlockInfo =
           new HLoopBlockInformation(
               HLoopBlockInformation.DO_WHILE_LOOP,
               null,
               wrapExpressionGraph(conditionExpression),
               wrapStatementGraph(bodyGraph),
               null,
               loopEntryBlock.loopInformation.target,
               loopEntryBlock.loopInformation.labels,
-              sourceInformationForBeginEndToken(node));
+              sourceInformationBuilder.buildLoop(node));
       loopEntryBlock.setBlockFlow(loopBlockInfo, current);
       loopInfo.loopBlockInformation = loopBlockInfo;
     } else {
       // Since the loop has no back edge, we remove the loop information on the
       // header.
       loopEntryBlock.loopInformation = null;
 
       if (jumpHandler.hasAnyBreak()) {
         // Null branchBlock because the body of the do-while loop always aborts,
         // so we never get to the condition.
@@ skipping 4090 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }