Implement support for Element.documentationComment in summaries.

pkg/analyzer/lib/src/summary/summarize_elements.dart

 // Copyright (c) 2015, 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 serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 189 matching lines @@
             kind: PrelinkedReferenceKind.typedef,
             name: typedef.name,
             numTypeParameters: typedef.typeParameters.length));
       }
     }
     if (unitNum == 0) {
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
         b.libraryNameOffset = libraryElement.nameOffset;
         b.libraryNameLength = libraryElement.nameLength;
+        b.libraryDocumentationComment = serializeDocumentation(libraryElement);
       }
       b.publicNamespace = encodeUnlinkedPublicNamespace(ctx,
           exports: libraryElement.exports.map(serializeExportPublic).toList(),
           parts: libraryElement.parts
               .map((CompilationUnitElement e) => e.uri)
               .toList(),
           names: names);
       b.exports = libraryElement.exports.map(serializeExportNonPublic).toList();
       b.imports = libraryElement.imports.map(serializeImport).toList();
       b.parts = libraryElement.parts
@@ skipping 120 matching lines @@
         PropertyInducingElement field = accessor.variable;
         if (field != null && !field.isSynthetic) {
           fields.add(serializeVariable(field));
         }
       }
     }
     b.fields = fields;
     b.executables = executables;
     b.isAbstract = classElement.isAbstract;
     b.isMixinApplication = classElement.isMixinApplication;
+    b.documentationComment = serializeDocumentation(classElement);
     return b;
   }
 
   /**
    * Serialize the given [combinator] into an [UnlinkedCombinator].
    */
   UnlinkedCombinatorBuilder serializeCombinator(
       NamespaceCombinator combinator) {
     UnlinkedCombinatorBuilder b = new UnlinkedCombinatorBuilder(ctx);
     if (combinator is ShowElementCombinator) {
@@ skipping 12 matching lines @@
   int serializeDependency(LibraryElement dependentLibrary) {
     return dependencyMap.putIfAbsent(dependentLibrary, () {
       int index = dependencies.length;
       dependencies.add(encodePrelinkedDependency(ctx,
           uri: dependentLibrary.source.uri.toString()));
       return index;
     });
   }
 
   /**
+   * Serialize documentation from the given [element], creating an
+   * [UnlinkedDocumentationComment].
+   *
+   * If [element] has no documentation, `null` is returned.
+   */
+  UnlinkedDocumentationCommentBuilder serializeDocumentation(Element element) {
+    if (element.documentationComment == null) {
+      return null;
+    }
+    return encodeUnlinkedDocumentationComment(ctx,
+        text: element.documentationComment);
+  }
+
+  /**
    * Return the index of the entry in the references table
    * ([UnlinkedLibrary.references] and [PrelinkedLibrary.references])
    * representing the pseudo-type `dynamic`.
    */
   int serializeDynamicReference() => 0;
 
   /**
    * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
   UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder(ctx);
     b.name = enumElement.name;
     b.nameOffset = enumElement.nameOffset;
     List<UnlinkedEnumValueBuilder> values = <UnlinkedEnumValueBuilder>[];
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
         values.add(encodeUnlinkedEnumValue(ctx,
-            name: field.name, nameOffset: field.nameOffset));
+            name: field.name,
+            nameOffset: field.nameOffset,
+            documentationComment: serializeDocumentation(field)));
       }
     }
     b.values = values;
+    b.documentationComment = serializeDocumentation(enumElement);
     return b;
   }
 
   /**
    * Serialize the given [executableElement], creating an [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       ExecutableElement executableElement) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder(ctx);
     b.name = executableElement.name;
@@ skipping 18 matching lines @@
       b.isConst = executableElement.isConst;
       b.isFactory = executableElement.isFactory;
     } else {
       b.kind = UnlinkedExecutableKind.functionOrMethod;
     }
     b.isAbstract = executableElement.isAbstract;
     b.isStatic = executableElement.isStatic &&
         executableElement.enclosingElement is ClassElement;
     b.hasImplicitReturnType = executableElement.hasImplicitReturnType;
     b.isExternal = executableElement.isExternal;
+    b.documentationComment = serializeDocumentation(executableElement);
     return b;
   }
 
   /**
    * Serialize the given [exportElement] into an [UnlinkedExportNonPublic].
    */
   UnlinkedExportNonPublicBuilder serializeExportNonPublic(
       ExportElement exportElement) {
     UnlinkedExportNonPublicBuilder b = new UnlinkedExportNonPublicBuilder(ctx);
     b.offset = exportElement.nameOffset;
@@ skipping 116 matching lines @@
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder(ctx);
     b.name = typedefElement.name;
     b.nameOffset = typedefElement.nameOffset;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     if (!typedefElement.returnType.isVoid) {
       b.returnType =
           serializeTypeRef(typedefElement.returnType, typedefElement);
     }
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
+    b.documentationComment = serializeDocumentation(typedefElement);
     return b;
   }
 
   /**
    * Serialize the given [typeParameter] into an [UnlinkedTypeParam].
    */
   UnlinkedTypeParamBuilder serializeTypeParam(
       TypeParameterElement typeParameter) {
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder(ctx);
     b.name = typeParameter.name;
@@ skipping 87 matching lines @@
    */
   UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
     b.nameOffset = variable.nameOffset;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
+    b.documentationComment = serializeDocumentation(variable);
     return b;
   }
 }