Generate fileUris.

lib/kernel.dart

 // Copyright (c) 2016, 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.md file.
 
 library rasta.kernel;
 
 import 'dart:async' show
     Future;
 
 import 'dart:collection' show
@@ skipping 76 matching lines @@
 
   final Set<ir.TreeNode> checkedNodes = new Set<ir.TreeNode>();
 
   final Map<LibraryElement, Map<String, int>> mixinApplicationNamesByLibrary =
       <LibraryElement, Map<String, int>>{};
 
   /// FIFO queue of work that needs to be completed before the returned AST
   /// nodes are correct.
   final Queue<WorkItem> workQueue = new Queue<WorkItem>();
 
+  // TODO(ahe): this should be pruned when unloading libraries.
+  final Map<String, List<int>> lineStarts = <String, List<int>>{};
+
   Kernel(this.compiler);
 
   bool hasMainMethod(Uri uri) {
     LibraryElement library = compiler.libraryLoader.lookupLibrary(uri);
     return library.localLookup("main") != null;
   }
 
   void addWork(Element element, WorkAction action) {
     workQueue.addLast(new WorkItem(element, action));
   }
@@ skipping 39 matching lines @@
       }
       irLibrary = libraryToIr(element.library);
     }
     return new ir.Name(name, irLibrary);
   }
 
   Future<ir.Library> loadLibrary(Uri uri) async {
     return libraryToIr(await compiler.libraryLoader.loadLibrary(uri));
   }
 
+  String fileUri(Element element) {
+    String fileUri = "${element.compilationUnit.script.resourceUri}";
+    lineStarts[fileUri] = <int>[0];
+    return fileUri;
+  }
+
+  void addLineStartsTo(ir.Program program) {
+    program.uriToLineStarts.addAll(lineStarts);
+  }
+
   ir.Library libraryToIr(LibraryElement library) {
     library = library.declaration;
     return libraries.putIfAbsent(library, () {
       String name = library.hasLibraryName ? library.libraryName : null;
       ir.Library libraryNode = new ir.Library(
           library.canonicalUri, name: name, classes: null, procedures: null,
           fields: null);
+      libraryNode.fileUri = fileUri(library);
       addWork(library, () {
         Queue<ir.Class> classes = new Queue<ir.Class>();
         Queue<ir.Member> members = new Queue<ir.Member>();
         library.implementation.forEachLocalMember((Element e) {
           if (e.isClass) {
             classes.addFirst(classToIr(e));
           } else if (e.isFunction || e.isAccessor) {
             members.addFirst(functionToIr(e));
           } else if (e.isField) {
             members.addFirst(fieldToIr(e));
@@ skipping 28 matching lines @@
 
   ir.Class classToIr(ClassElement cls) {
     cls = cls.declaration;
     return classes.putIfAbsent(cls, () {
       cls.ensureResolved(compiler.resolution);
       compiler.enqueuer.resolution.emptyDeferredTaskQueue();
       String name = computeName(cls);
       ir.Class classNode = new ir.Class(
           name: name, isAbstract: cls.isAbstract,
           typeParameters: null, implementedTypes: null, constructors: null,
-          procedures: null, fields: null);
+          procedures: null, fields: null, fileUri: fileUri(cls));
       addWork(cls, () {
         if (cls.supertype != null) {
           classNode.supertype = interfaceTypeToIr(cls.supertype);
         }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         cls.implementation.forEachMember(
             (ClassElement enclosingClass, Element member) {
@@ skipping 147 matching lines @@
       if (function.isGenerativeConstructor) {
         member = constructor = new ir.Constructor(
             null, name: name, isConst: function.isConst,
             isExternal: isNative || function.isExternal, initializers: null);
       } else {
         member = procedure = new ir.Procedure(
             name, null, null, isAbstract: function.isAbstract,
             isStatic: function.isStatic || function.isTopLevel
                 || function.isFactoryConstructor,
             isExternal: isNative || function.isExternal,
+            fileUri: fileUri(function),
             isConst: false); // TODO(ahe): When is this true?
       }
       addWork(function, () {
         setParent(member, function);
         KernelVisitor visitor =
             new KernelVisitor(function, function.treeElements, this);
         beginFactoryScope(function);
         IrFunction irFunction = visitor.buildFunction();
         // TODO(ahe): Add addFunction/set function to [ir.Procedure].
         irFunction.node.parent = member;
@@ skipping 60 matching lines @@
     return fields.putIfAbsent(field, () {
       compiler.analyzeElement(field);
       compiler.enqueuer.resolution.emptyDeferredTaskQueue();
       field = field.implementation;
       ir.DartType type = field.isMalformed
           ? const ir.InvalidType()
           : typeToIr(field.type);
       ir.Field fieldNode = new ir.Field(
           irName(field.memberName.text, field), type: type, initializer: null,
           isFinal: field.isFinal, isStatic: field.isStatic || field.isTopLevel,
-          isConst: field.isConst);
+          isConst: field.isConst, fileUri: fileUri(field));
       addWork(field, () {
         setParent(fieldNode, field);
         if (!field.isMalformed && !field.isInstanceMember &&
             field.initializer != null) {
           KernelVisitor visitor =
               new KernelVisitor(field, field.treeElements, this);
           fieldNode.initializer = visitor.buildInitializer()
               ..parent = fieldNode;
         }
       });
@@ skipping 217 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }