Fix source information positions for deserialized patched elements.

pkg/compiler/lib/src/io/source_information.dart

 // Copyright (c) 2015, 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.source_information;
 
 import '../common.dart';
-import '../elements/elements.dart' show AstElement, LocalElement, ResolvedAst;
+import '../elements/elements.dart'
+    show
+        AstElement,
+        CompilationUnitElement,
+        LocalElement,
+        ResolvedAst,
+        ResolvedAstKind;
 import '../js/js.dart' show JavaScriptNodeSourceInformation;
+import '../script.dart';
 import '../tree/tree.dart' show Node;
 import 'source_file.dart';
 
 /// Interface for passing source information, for instance for use in source
 /// maps, through the backend.
 abstract class SourceInformation extends JavaScriptNodeSourceInformation {
   const SourceInformation();
 
   SourceSpan get sourceSpan;
 
@@ skipping 10 matching lines @@
   List<SourceLocation> get sourceLocations;
 
   /// Return a short textual representation of the source location.
   String get shortText;
 }
 
 /// Strategy for creating, processing and applying [SourceInformation].
 class SourceInformationStrategy {
   const SourceInformationStrategy();
 
-  /// Create a [SourceInformationBuilder] for [element].
-  SourceInformationBuilder createBuilderForContext(AstElement element) {
+  /// Create a [SourceInformationBuilder] for [resolvedAst].
+  SourceInformationBuilder createBuilderForContext(ResolvedAst resolvedAst) {
     return const SourceInformationBuilder();
   }
 
   /// Generate [SourceInformation] marker for non-preamble code.
   SourceInformation buildSourceMappedMarker() => null;
 
   /// Called when compilation has completed.
   void onComplete() {}
 }
 
 /// Interface for generating [SourceInformation].
 class SourceInformationBuilder {
   const SourceInformationBuilder();
 
-  /// Create a [SourceInformationBuilder] for [element].
-  SourceInformationBuilder forContext(AstElement element) => this;
+  /// Create a [SourceInformationBuilder] for [resolvedAst].
+  SourceInformationBuilder forContext(ResolvedAst resolvedAst) => this;
 
   /// Generate [SourceInformation] the declaration of the element in
   /// [resolvedAst].
   SourceInformation buildDeclaration(ResolvedAst resolvedAst) => null;
 
   /// Generate [SourceInformation] for the generic [node].
   @deprecated
   SourceInformation buildGeneric(Node node) => null;
 
   /// Generate [SourceInformation] for an instantiation of a class using [node]
@@ skipping 76 matching lines @@
   /// Generate [SourceInformation] for the switch case in [node].
   SourceInformation buildSwitchCase(Node node) => null;
 }
 
 /// A location in a source file.
 abstract class SourceLocation {
   final SourceFile _sourceFile;
   int _line;
 
   SourceLocation(this._sourceFile) {
-    assert(isValid);
+    assert(invariant(new SourceSpan(sourceUri, 0, 0), isValid,
+        message: "Invalid source location in ${sourceUri}: "
+            "offset=$offset, length=${_sourceFile.length}."));
   }
 
   /// The absolute URI of the source file of this source location.
   Uri get sourceUri => _sourceFile.uri;
 
   /// The character offset of the this source location into the source file.
   int get offset;
 
   /// The 0-based line number of the [offset].
   int get line {
@@ skipping 72 matching lines @@
     return '${computeElementNameForSourceMaps(local.executableContext)}.$name';
   } else if (element.enclosingClass != null) {
     if (element.enclosingClass.isClosure) {
       return computeElementNameForSourceMaps(element.enclosingClass);
     }
     return '${element.enclosingClass.name}.${element.name}';
   } else {
     return element.name;
   }
 }
+
+/// Computes the [SourceFile] for the source code of [resolvedAst].
+SourceFile computeSourceFile(ResolvedAst resolvedAst) {
+  SourceFile sourceFile;
+  if (resolvedAst.kind != ResolvedAstKind.PARSED) {
+    // Synthesized node. Use the enclosing element for the location.
+    sourceFile = resolvedAst.element.compilationUnit.script.file;
+  } else {
+    Uri uri = resolvedAst.sourceUri;
+    AstElement implementation = resolvedAst.element.implementation;
+    Script script = implementation.compilationUnit.script;
+    if (uri == script.resourceUri) {
+      sourceFile = script.file;
+    } else {
+      // Slow path, happens only for deserialized elements.
+      // TODO(johnniwinther): Support a way to get a [SourceFile] from a
+      // [Uri].
+      for (CompilationUnitElement compilationUnit
+          in implementation.library.compilationUnits) {
+        Script script = compilationUnit.script;
+        if (uri == script.resourceUri) {
+          sourceFile = script.file;
+          break;
+        }
+      }
+    }
+  }
+  return sourceFile;
+}