Implement support for Element.documentationComment in summaries.

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 270 matching lines @@
               constructor, null, currentTypeArguments, false);
           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
       correspondingType.typeArguments = currentTypeArguments;
       classElement.type = correspondingType;
+      buildDocumentation(classElement, serializedClass.documentationComment);
       unitHolder.addType(classElement);
     } finally {
       currentTypeParameters = <TypeParameterElement>[];
     }
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
@@ skipping 23 matching lines @@
     ConstructorElementImpl constructorElement = new ConstructorElementImpl(
         serializedExecutable.name, serializedExecutable.nameOffset);
     constructorElement.returnType = classType;
     buildExecutableCommonParts(constructorElement, serializedExecutable);
     constructorElement.factory = serializedExecutable.isFactory;
     constructorElement.const2 = serializedExecutable.isConst;
     holder.addConstructor(constructorElement);
   }
 
   /**
+   * Build the documentation for the given [element].  Does nothing if
+   * [serializedDocumentationComment] is `null`.
+   */
+  void buildDocumentation(ElementImpl element,
+      UnlinkedDocumentationComment serializedDocumentationComment) {
+    if (serializedDocumentationComment != null) {
+      element.documentationComment = serializedDocumentationComment.text;
+    }
+  }
+
+  /**
    * Resynthesize the [ClassElement] corresponding to an enum, along with the
    * associated fields and implicit accessors.
    */
   void buildEnum(UnlinkedEnum serializedEnum) {
     assert(!isCoreLibrary);
     // TODO(paulberry): add offset support (for this element type and others)
     ClassElementImpl classElement =
         new ClassElementImpl(serializedEnum.name, serializedEnum.nameOffset);
     classElement.enum2 = true;
     InterfaceType enumType = new InterfaceTypeImpl(classElement);
     classElement.type = enumType;
     classElement.supertype = summaryResynthesizer.typeProvider.objectType;
+    buildDocumentation(classElement, serializedEnum.documentationComment);
     ElementHolder memberHolder = new ElementHolder();
     FieldElementImpl indexField = new FieldElementImpl('index', -1);
     indexField.final2 = true;
     indexField.synthetic = true;
     indexField.type = summaryResynthesizer.typeProvider.intType;
     memberHolder.addField(indexField);
     buildImplicitAccessors(indexField, memberHolder);
     FieldElementImpl valuesField = new ConstFieldElementImpl('values', -1);
     valuesField.synthetic = true;
     valuesField.const3 = true;
@@ skipping 118 matching lines @@
     } else {
       executableElement.returnType = VoidTypeImpl.instance;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, oldTypeArguments, false);
     executableElement.hasImplicitReturnType =
         serializedExecutable.hasImplicitReturnType;
     executableElement.external = serializedExecutable.isExternal;
     currentTypeParameters.removeRange(
         oldTypeParametersLength, currentTypeParameters.length);
+    buildDocumentation(
+        executableElement, serializedExecutable.documentationComment);
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
   ExportElement buildExport(UnlinkedExportPublic serializedExportPublic,
       UnlinkedExportNonPublic serializedExportNonPublic) {
     ExportElementImpl exportElement =
         new ExportElementImpl(serializedExportNonPublic.offset);
     String exportedLibraryUri = summaryResynthesizer.sourceFactory
@@ skipping 141 matching lines @@
   /**
    * Main entry point.  Resynthesize the [LibraryElement] and return it.
    */
   LibraryElement buildLibrary() {
     bool hasName = unlinkedUnits[0].libraryName.isNotEmpty;
     LibraryElementImpl libraryElement = new LibraryElementImpl(
         summaryResynthesizer.context,
         unlinkedUnits[0].libraryName,
         hasName ? unlinkedUnits[0].libraryNameOffset : -1,
         unlinkedUnits[0].libraryNameLength);
+    buildDocumentation(
+        libraryElement, unlinkedUnits[0].libraryDocumentationComment);
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl(librarySource.shortName);
     libraryElement.definingCompilationUnit = definingCompilationUnit;
     definingCompilationUnit.source = librarySource;
     definingCompilationUnit.librarySource = librarySource;
     List<CompilationUnitElement> parts = <CompilationUnitElement>[];
     UnlinkedUnit unlinkedDefiningUnit = unlinkedUnits[0];
     assert(unlinkedDefiningUnit.publicNamespace.parts.length + 1 ==
         prelinkedLibrary.units.length);
     for (int i = 1; i < prelinkedLibrary.units.length; i++) {
@@ skipping 206 matching lines @@
           serializedTypedef.parameters.map(buildParameter).toList();
       if (serializedTypedef.returnType != null) {
         functionTypeAliasElement.returnType =
             buildType(serializedTypedef.returnType);
       } else {
         functionTypeAliasElement.returnType = VoidTypeImpl.instance;
       }
       functionTypeAliasElement.type =
           new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
       functionTypeAliasElement.typeParameters = currentTypeParameters;
+      buildDocumentation(
+          functionTypeAliasElement, serializedTypedef.documentationComment);
       unitHolder.addTypeAlias(functionTypeAliasElement);
     } finally {
       currentTypeParameters = <TypeParameterElement>[];
     }
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
    * its bound.
    *
@@ skipping 32 matching lines @@
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildVariableCommonParts(PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
     element.type = buildType(serializedVariable.type);
     element.const3 = serializedVariable.isConst;
     element.hasImplicitType = serializedVariable.hasImplicitType;
+    buildDocumentation(element, serializedVariable.documentationComment);
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
     }
@@ skipping 44 matching lines @@
         break;
       }
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
     return entryPoint;
   }
 }