Add documentationComment for Class to Kernel. Parse it. Resynthesize in Analyzer.

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:typed_data' show Uint8List;
 
@@ skipping 57 matching lines @@
 import 'outline_builder.dart' show OutlineBuilder;
 
 import 'source_class_builder.dart' show SourceClassBuilder;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
 class SourceLoader<L> extends Loader<L> {
   /// The [FileSystem] which should be used to access files.
   final FileSystem fileSystem;
 
+  /// Whether comments should be scanned and parsed.
+  final bool includeComments;
+
   final Map<Uri, List<int>> sourceBytes = <Uri, List<int>>{};
 
   final bool excludeSource = CompilerContext.current.options.excludeSource;
 
   // Used when building directly to kernel.
   ClassHierarchy hierarchy;
   CoreTypes coreTypes;
 
   TypeInferenceEngine typeInferenceEngine;
 
   Instrumentation instrumentation;
 
-  SourceLoader(this.fileSystem, KernelTarget target) : super(target);
+  SourceLoader(this.fileSystem, this.includeComments, KernelTarget target)
+      : super(target);
 
   Future<Token> tokenize(SourceLibraryBuilder library,
       {bool suppressLexicalErrors: false}) async {
     Uri uri = library.fileUri;
     // TODO(sigmund): source-loader shouldn't check schemes, but defer to the
     // underlying file system to decide whether it is supported.
     if (uri == null || uri.scheme != "file" && uri.scheme != "multi-root") {
       return deprecated_inputError(
           library.uri, -1, "Not found: ${library.uri}.");
     }
 
     // Get the library text from the cache, or read from the file system.
     List<int> bytes = sourceBytes[uri];
     if (bytes == null) {
       try {
         List<int> rawBytes = await fileSystem.entityForUri(uri).readAsBytes();
         Uint8List zeroTerminatedBytes = new Uint8List(rawBytes.length + 1);
         zeroTerminatedBytes.setRange(0, rawBytes.length, rawBytes);
         bytes = zeroTerminatedBytes;
         sourceBytes[uri] = bytes;
       } on FileSystemException catch (e) {
         return deprecated_inputError(uri, -1, e.message);
       }
     }
 
     byteCount += bytes.length - 1;
-    ScannerResult result = scan(bytes);
+    ScannerResult result = scan(bytes, includeComments: includeComments);
     Token token = result.tokens;
     if (!suppressLexicalErrors) {
       List<int> source = getSource(bytes);
       target.addSourceInformation(library.fileUri, result.lineStarts, source);
     }
     while (token is ErrorToken) {
       if (!suppressLexicalErrors) {
         ErrorToken error = token;
         library.addCompileTimeError(
             templateUnspecified.withArguments(error.assertionMessage),
@@ skipping 401 matching lines @@
   Expression throwCompileConstantError(Expression error) {
     return target.backendTarget.throwCompileConstantError(coreTypes, error);
   }
 
   Expression buildCompileTimeError(Message message, int offset, Uri uri) {
     String text = target.context
         .format(message.withLocation(uri, offset), Severity.error);
     return target.backendTarget.buildCompileTimeError(coreTypes, text, offset);
   }
 }