Include source in kernel.

pkg/kernel/lib/analyzer/loader.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 file.
 library kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 102 matching lines @@
         this.applicationRoot = options.applicationRoot;
 
   String getLibraryName(LibraryElement element) {
     return element.name.isEmpty ? null : element.name;
   }
 
   ast.Library getLibraryReference(LibraryElement element) {
     var uri = applicationRoot.relativeUri(element.source.uri);
     return repository.getLibraryReference(uri)
       ..name ??= getLibraryName(element)
-      ..fileUri = "file://${element.source.fullName}";
+      ..fileUri = '${element.source.uri}';
   }
 
   void _buildTopLevelMember(
       ast.Member member, Element element, Declaration astNode) {
     assert(member.parent != null);
     new MemberBodyBuilder(this, member, element).build(astNode);
   }
 
   /// True if [element] is in the process of being loaded by
   /// [_buildLibraryBody].
@@ skipping 127 matching lines @@
   /// Returns the IR for a class, at a temporary loading level.
   ///
   /// The returned class has the correct name, flags, type parameter arity,
   /// and enclosing library.
   ast.Class getClassReference(ClassElement element) {
     var classNode = _classes[element];
     if (classNode != null) return classNode;
     _classes[element] = classNode = new ast.Class(
         name: element.name,
         isAbstract: element.isAbstract,
-        fileUri: "file://${element.source.fullName}");
+        fileUri: '${element.source.uri}');
     classNode.level = ast.ClassLevel.Temporary;
     var library = getLibraryReference(element.library);
     library.addClass(classNode);
     // Initialize type parameter list without bounds.
     for (var parameter in element.typeParameters) {
       var parameterNode = new ast.TypeParameter(parameter.name);
       _classTypeParameters[parameter] = parameterNode;
       classNode.typeParameters.add(parameterNode);
       parameterNode.parent = classNode;
     }
@@ skipping 43 matching lines @@
                   : mixinType.typeArguments);
         } else {
           // Generate a new class specific for this mixin application.
           var freshParameters =
               getFreshTypeParameters(classNode.typeParameters);
           var mixinClass = new ast.Class(
               name: '${classNode.name}^${mixinType.classNode.name}',
               isAbstract: true,
               typeParameters: freshParameters.freshTypeParameters,
               supertype: freshParameters.substituteSuper(supertype),
-              mixedInType: freshParameters.substituteSuper(mixinType));
+              mixedInType: freshParameters.substituteSuper(mixinType),
+              fileUri: classNode.fileUri);
           mixinClass.level = ast.ClassLevel.Type;
           supertype = new ast.Supertype(mixinClass,
               classNode.typeParameters.map(makeTypeParameterType).toList());
           addMixinClassToLibrary(mixinClass, classNode.enclosingLibrary);
           // This class cannot be used from anywhere else, so don't try to
           // generate shared mixin applications using it.
           useSharedMixin = false;
         }
       }
       classNode.supertype = supertype;
@@ skipping 92 matching lines @@
         ConstructorElement constructor = element;
         if (constructor.isFactory) {
           return new ast.Procedure(
               _nameOfMember(constructor),
               ast.ProcedureKind.Factory,
               scope.buildFunctionInterface(constructor),
               isAbstract: false,
               isStatic: true,
               isExternal: constructor.isExternal,
               isConst: constructor.isConst,
-              fileUri: "file://${element.source.fullName}");
+              fileUri: '${element.source.uri}');
         }
         return new ast.Constructor(scope.buildFunctionInterface(constructor),
             name: _nameOfMember(element),
             isConst: constructor.isConst,
             isExternal: constructor.isExternal);
 
       case ElementKind.FIELD:
       case ElementKind.TOP_LEVEL_VARIABLE:
         VariableElement variable = element;
         return new ast.Field(_nameOfMember(variable),
             isStatic: variable.isStatic,
             isFinal: variable.isFinal,
             isConst: variable.isConst,
             type: scope.buildType(variable.type),
-            fileUri: "file://${element.source.fullName}")
-          ..fileOffset = element.nameOffset;
+            fileUri: '${element.source.uri}')..fileOffset = element.nameOffset;
 
       case ElementKind.METHOD:
       case ElementKind.GETTER:
       case ElementKind.SETTER:
       case ElementKind.FUNCTION:
         if (element is FunctionElement &&
             element.enclosingElement is! CompilationUnitElement) {
           throw 'Function $element is nested in ${element.enclosingElement} '
               'and hence is not a member';
         }
         ExecutableElement executable = element;
         return new ast.Procedure(
             _nameOfMember(element),
             _procedureKindOf(executable),
             scope.buildFunctionInterface(executable),
             isAbstract: executable.isAbstract,
             isStatic: executable.isStatic,
             isExternal: executable.isExternal,
-            fileUri: "file://${element.source.fullName}");
+            fileUri: '${element.source.uri}');
 
       default:
         throw 'Unexpected member kind: $element';
     }
   }
 
   ast.ProcedureKind _procedureKindOf(ExecutableElement element) {
     if (element is PropertyAccessorElement) {
       return element.isGetter
           ? ast.ProcedureKind.Getter
@@ skipping 85 matching lines @@
           : typeArguments;
       var mixinArgs = typeArguments.length != mixedInClass.typeParameters.length
           ? typeArguments.sublist(0, mixedInClass.typeParameters.length)
           : typeArguments;
       var result = new ast.Class(
           name: name,
           isAbstract: true,
           typeParameters: fresh.freshTypeParameters,
           supertype: new ast.Supertype(superclass, superArgs),
           mixedInType: new ast.Supertype(mixedInClass, mixinArgs),
-          fileUri: mixedInClass.fileUri);
+          fileUri: library.fileUri);
       result.level = ast.ClassLevel.Type;
       library.addClass(result);
       return result;
     });
   }
 
   String formatErrorMessage(
       AnalysisError error, String filename, LineInfo lines) {
     var location = lines.getLocation(error.offset);
     return '[error] ${error.message} ($filename, '
@@ skipping 87 matching lines @@
     loadEverything(target: target, compileSdk: compileSdk);
     var program = new ast.Program(repository.libraries);
     program.mainMethod = library.procedures.firstWhere(
         (member) => member.name?.name == 'main',
         orElse: () => null);
     for (LibraryElement libraryElement in libraryElements) {
       for (CompilationUnitElement compilationUnitElement
           in libraryElement.units) {
         var source = compilationUnitElement.source;
         LineInfo lineInfo = context.computeLineInfo(source);
-        program.uriToLineStarts["file://${source.fullName}"] =
-            new List<int>.generate(lineInfo.lineCount, lineInfo.getOffsetOfLine,
-                growable: false);
+        String sourceCode;
+        try {
+          sourceCode = context.getContents(source).data;
+        } catch (e) {
+          // The source's contents could not be accessed.
+          sourceCode = '';
+        }
+        program.uriToSource['${source.uri}'] =
+            new ast.Source(lineInfo.lineStarts, sourceCode);
       }
     }
     return program;
   }
 
   ast.Library loadLibrary(Uri uri) {
     ast.Library library =
         repository.getLibraryReference(applicationRoot.relativeUri(uri));
     ensureLibraryIsLoaded(library);
     return library;
@@ skipping 146 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }