Add Member.documentationComment and use it to resynthesize documentation from Kernel.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.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.kernel_procedure_builder;
 
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
@@ skipping 63 matching lines @@
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
   final String nativeMethodName;
 
   FunctionNode function;
 
   Statement actualBody;
 
   KernelFunctionBuilder(
+      String documentationComment,
       List<MetadataBuilder> metadata,
       int modifiers,
       KernelTypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       KernelLibraryBuilder compilationUnit,
       int charOffset,
       this.nativeMethodName)
-      : super(metadata, modifiers, returnType, name, typeVariables, formals,
-            compilationUnit, charOffset);
+      : super(documentationComment, metadata, modifiers, returnType, name,
+            typeVariables, formals, compilationUnit, charOffset);
 
   void set body(Statement newBody) {
     if (newBody != null) {
       if (isAbstract) {
         return internalProblem(messageInternalProblemBodyOnAbstractMethod,
             newBody.fileOffset, fileUri);
       }
       if (isExternal) {
         return library.addCompileTimeError(
             messageExternalMethodWithBody, newBody.fileOffset, fileUri);
@@ skipping 95 matching lines @@
 
 class KernelProcedureBuilder extends KernelFunctionBuilder {
   final KernelProcedure procedure;
   final int charOpenParenOffset;
 
   AsyncMarker actualAsyncModifier = AsyncMarker.Sync;
 
   final ConstructorReferenceBuilder redirectionTarget;
 
   KernelProcedureBuilder(
+      String documentationComment,
       List<MetadataBuilder> metadata,
       int modifiers,
       KernelTypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       ProcedureKind kind,
       KernelLibraryBuilder compilationUnit,
       int charOffset,
       this.charOpenParenOffset,
       int charEndOffset,
       [String nativeMethodName,
       this.redirectionTarget])
       : procedure = new KernelProcedure(null, kind, null, returnType == null,
             fileUri: compilationUnit?.relativeFileUri)
           ..fileOffset = charOffset
           ..fileEndOffset = charEndOffset,
-        super(metadata, modifiers, returnType, name, typeVariables, formals,
-            compilationUnit, charOffset, nativeMethodName);
+        super(
+            documentationComment,
+            metadata,
+            modifiers,
+            returnType,
+            name,
+            typeVariables,
+            formals,
+            compilationUnit,
+            charOffset,
+            nativeMethodName);
 
   ProcedureKind get kind => procedure.kind;
 
   AsyncMarker get asyncModifier => actualAsyncModifier;
 
   Statement get body {
     if (actualBody == null &&
         redirectionTarget == null &&
         !isAbstract &&
         !isExternal) {
@@ skipping 30 matching lines @@
     if (procedure.name == null) {
       procedure.function = buildFunction(library);
       procedure.function.parent = procedure;
       procedure.function.fileOffset = charOpenParenOffset;
       procedure.function.fileEndOffset = procedure.fileEndOffset;
       procedure.isAbstract = isAbstract;
       procedure.isStatic = isStatic;
       procedure.isExternal = isExternal;
       procedure.isConst = isConst;
       procedure.name = new Name(name, library.target);
+      procedure.documentationComment = documentationComment;
     }
     if (isEligibleForTopLevelInference) {
       library.loader.typeInferenceEngine.recordMember(procedure);
     }
     return procedure;
   }
 
   Procedure get target => procedure;
 
   @override
@@ skipping 14 matching lines @@
 
   final int charOpenParenOffset;
 
   bool hasMovedSuperInitializer = false;
 
   SuperInitializer superInitializer;
 
   RedirectingInitializer redirectingInitializer;
 
   KernelConstructorBuilder(
+      String documentationComment,
       List<MetadataBuilder> metadata,
       int modifiers,
       KernelTypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       KernelLibraryBuilder compilationUnit,
       int charOffset,
       this.charOpenParenOffset,
       int charEndOffset,
       [String nativeMethodName])
       : constructor = new Constructor(null)
           ..fileOffset = charOffset
           ..fileEndOffset = charEndOffset,
-        super(metadata, modifiers, returnType, name, typeVariables, formals,
-            compilationUnit, charOffset, nativeMethodName);
+        super(
+            documentationComment,
+            metadata,
+            modifiers,
+            returnType,
+            name,
+            typeVariables,
+            formals,
+            compilationUnit,
+            charOffset,
+            nativeMethodName);
 
   bool get isInstanceMember => false;
 
   bool get isConstructor => true;
 
   AsyncMarker get asyncModifier => AsyncMarker.Sync;
 
   ProcedureKind get kind => null;
 
   bool get isRedirectingGenerativeConstructor {
     return isRedirectingGenerativeConstructorImplementation(constructor);
   }
 
   Constructor build(SourceLibraryBuilder library) {
     if (constructor.name == null) {
       constructor.function = buildFunction(library);
       constructor.function.parent = constructor;
       constructor.function.fileOffset = charOpenParenOffset;
       constructor.function.fileEndOffset = constructor.fileEndOffset;
       constructor.isConst = isConst;
       constructor.isExternal = isExternal;
       constructor.name = new Name(name, library.target);
+      constructor.documentationComment = documentationComment;
     }
     return constructor;
   }
 
   FunctionNode buildFunction(LibraryBuilder library) {
     // TODO(ahe): Should complain if another type is explicitly set.
     return super.buildFunction(library)..returnType = const VoidType();
   }
 
   Constructor get target => constructor;
@@ skipping 51 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }