[Fasta] include source code in dill

pkg/front_end/lib/src/fasta/source/source_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 fasta.source_loader;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show FileSystemException;
 
+import 'dart:typed_data' show Uint8List;
+
 import '../scanner/io.dart' show readBytesFromFile;
 
 import '../scanner.dart' show ErrorToken, ScannerResult, Token, scan;
 
 import '../parser/class_member_parser.dart' show ClassMemberParser;
 
 import 'package:kernel/ast.dart' show Program;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
@@ skipping 12 matching lines @@
 import '../loader.dart' show Loader;
 
 import '../target_implementation.dart' show TargetImplementation;
 
 import 'diet_listener.dart' show DietListener;
 
 import 'diet_parser.dart' show DietParser;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
+import '../compiler_context.dart' show CompilerContext;
+
 class SourceLoader<L> extends Loader<L> {
   final Map<Uri, List<int>> sourceBytes = <Uri, List<int>>{};
+  final includeSource = CompilerContext.current.options.includeSource;
 
   // Used when building directly to kernel.
   ClassHierarchy hierarchy;
   CoreTypes coreTypes;
 
   SourceLoader(TargetImplementation target) : super(target);
 
   Future<Token> tokenize(SourceLibraryBuilder library,
       {bool suppressLexicalErrors: false}) async {
     Uri uri = library.fileUri;
     if (uri == null || uri.scheme != "file") {
       return inputError(library.uri, -1, "Not found: ${library.uri}.");
     }
     try {
       List<int> bytes = sourceBytes[uri];
       if (bytes == null) {
         bytes = sourceBytes[uri] = await readBytesFromFile(uri);
       }
       byteCount += bytes.length - 1;
       ScannerResult result = scan(bytes);
       Token token = result.tokens;
       if (!suppressLexicalErrors) {
-        target.addLineStarts(library.fileUri, result.lineStarts);
+        List<int> source = getSource(bytes);
+        target.addSourceInformation(library.fileUri, result.lineStarts, source);
       }
       while (token is ErrorToken) {
         if (!suppressLexicalErrors) {
           ErrorToken error = token;
           printUnexpected(uri, token.charOffset, error.assertionMessage);
         }
         token = token.next;
       }
       return token;
     } on FileSystemException catch (e) {
       String message = e.message;
       String osMessage = e.osError?.message;
       if (osMessage != null && osMessage.isNotEmpty) {
         message = osMessage;
       }
       return inputError(uri, -1, message);
     }
   }
 
+  List<int> getSource(List<int> bytes) {
+    if (!includeSource) return const <int>[];
+
+    // bytes is 0-terminated. We don't want that included.
+    if (bytes is Uint8List) {
+      return new Uint8List.view(
+          bytes.buffer, bytes.offsetInBytes, bytes.length - 1);
+    }
+    return bytes.sublist(0, bytes.length - 1);
+  }
+
   Future<Null> buildOutline(SourceLibraryBuilder library) async {
     Token tokens = await tokenize(library);
     if (tokens == null) return;
     OutlineBuilder listener = new OutlineBuilder(library);
     new ClassMemberParser(listener).parseUnit(tokens);
   }
 
   Future<Null> buildBody(LibraryBuilder library) async {
     if (library is SourceLibraryBuilder) {
       // We tokenize source files twice to keep memory usage low. This is the
@@ skipping 240 matching lines @@
 
   void computeHierarchy(Program program) {
     hierarchy = new ClassHierarchy(program);
     ticker.logMs("Computed class hierarchy");
     coreTypes = new CoreTypes(program);
     ticker.logMs("Computed core types");
   }
 
   List<Uri> getDependencies() => sourceBytes.keys.toList();
 }