Cache element docs (and add to completions) (#23694).

pkg/analyzer/lib/src/task/dart.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 analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 66 matching lines @@
         'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
  * A list of the [ConstantEvaluationTarget]s defined in a unit.  This includes
  * constants defined at top level, statically inside classes, and local to
  * functions, as well as constant constructors, annotations, and default values
  * of parameters.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
-final ListResultDescriptor<
-        ConstantEvaluationTarget> COMPILATION_UNIT_CONSTANTS =
+final ListResultDescriptor<ConstantEvaluationTarget>
+    COMPILATION_UNIT_CONSTANTS =
     new ListResultDescriptor<ConstantEvaluationTarget>(
         'COMPILATION_UNIT_CONSTANTS', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The element model associated with a single compilation unit.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ResultDescriptor<CompilationUnitElement> COMPILATION_UNIT_ELEMENT =
@@ skipping 53 matching lines @@
     new ListResultDescriptor<AnalysisError>(
         'HINT_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
  * A list of the [VariableElement]s whose type should be inferred that another
  * inferable static variable (the target) depends on.
  *
  * The result is only available for [VariableElement]s, and only when strong
  * mode is enabled.
  */
-final ListResultDescriptor<
-        VariableElement> INFERABLE_STATIC_VARIABLE_DEPENDENCIES =
+final ListResultDescriptor<VariableElement>
+    INFERABLE_STATIC_VARIABLE_DEPENDENCIES =
     new ListResultDescriptor<VariableElement>(
         'INFERABLE_STATIC_VARIABLE_DEPENDENCIES', null);
 
 /**
  * A list of the [VariableElement]s defined in a unit whose type should be
  * inferred. This includes variables defined at the library level as well as
  * static members inside classes.
  *
  * The result is only available for [LibrarySpecificUnit]s, and only when strong
  * mode is enabled.
@@ skipping 588 matching lines @@
           source, unit, librarySpecificUnit.library);
     } else {
       new DeclarationResolver().resolve(unit, element);
     }
     //
     // Prepare constants.
     //
     ConstantFinder constantFinder =
         new ConstantFinder(context, source, librarySpecificUnit.library);
     unit.accept(constantFinder);
-    List<ConstantEvaluationTarget> constants = new List<
-        ConstantEvaluationTarget>.from(constantFinder.constantsToCompute);
+    List<ConstantEvaluationTarget> constants =
+        new List<ConstantEvaluationTarget>.from(
+            constantFinder.constantsToCompute);
     //
     // Record outputs.
     //
     outputs[COMPILATION_UNIT_CONSTANTS] = constants;
     outputs[COMPILATION_UNIT_ELEMENT] = element;
     outputs[RESOLVED_UNIT1] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
@@ skipping 116 matching lines @@
                 new ImportElementImpl(directive.offset);
             StringLiteral uriLiteral = importDirective.uri;
             if (uriLiteral != null) {
               importElement.uriOffset = uriLiteral.offset;
               importElement.uriEnd = uriLiteral.end;
             }
             importElement.uri = uriContent;
             importElement.deferred = importDirective.deferredKeyword != null;
             importElement.combinators = _buildCombinators(importDirective);
             importElement.importedLibrary = importedLibrary;
-            _setDocRange(importElement, importDirective);
+            _setDoc(importElement, importDirective);
             SimpleIdentifier prefixNode = directive.prefix;
             if (prefixNode != null) {
               importElement.prefixOffset = prefixNode.offset;
               String prefixName = prefixNode.name;
               PrefixElementImpl prefix = nameToPrefixMap[prefixName];
               if (prefix == null) {
                 prefix = new PrefixElementImpl.forNode(prefixNode);
                 nameToPrefixMap[prefixName] = prefix;
               }
               importElement.prefix = prefix;
@@ skipping 21 matching lines @@
             ExportElementImpl exportElement =
                 new ExportElementImpl(directive.offset);
             StringLiteral uriLiteral = exportDirective.uri;
             if (uriLiteral != null) {
               exportElement.uriOffset = uriLiteral.offset;
               exportElement.uriEnd = uriLiteral.end;
             }
             exportElement.uri = exportDirective.uriContent;
             exportElement.combinators = _buildCombinators(exportDirective);
             exportElement.exportedLibrary = exportedLibrary;
-            _setDocRange(exportElement, exportDirective);
+            _setDoc(exportElement, exportDirective);
             directive.element = exportElement;
             exports.add(exportElement);
             if (exportSourceKindMap[exportedSource] != SourceKind.LIBRARY) {
               errors.add(new AnalysisError(
                   exportedSource,
                   uriLiteral.offset,
                   uriLiteral.length,
                   CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
                   [uriLiteral.toSource()]));
             }
@@ skipping 20 matching lines @@
     // for details on library cycle invalidation.
     libraryElement.invalidateLibraryCycles();
     //
     // Record outputs.
     //
     outputs[LIBRARY_ELEMENT2] = libraryElement;
     outputs[BUILD_DIRECTIVES_ERRORS] = errors;
   }
 
   /**
-   * If the given [node] has a documentation comment, remember its range
-   * into the given [element].
+   * If the given [node] has a documentation comment, remember its content
+   * and range into the given [element].
    */
-  void _setDocRange(ElementImpl element, AnnotatedNode node) {
+  void _setDoc(ElementImpl element, AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null && comment.isDocumentation) {
+      element.documentationComment =
+          comment.tokens.map((Token t) => t.lexeme).join('\n');
       element.setDocRange(comment.offset, comment.length);
     }
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
@@ skipping 350 matching lines @@
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     libraryElement.entryPoint = entryPoint;
     libraryElement.parts = sourcedCompilationUnits;
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     if (sourcedCompilationUnits.isNotEmpty) {
       _patchTopLevelAccessors(libraryElement);
     }
     if (libraryDirective != null) {
-      _setDocRange(libraryElement, libraryDirective);
+      _setDoc(libraryElement, libraryDirective);
     }
     //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
     outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
   }
 
   /**
@@ skipping 67 matching lines @@
         TopLevelVariableElementImpl setterVariable = setter.variable;
         CompilationUnitElementImpl setterUnit = setterVariable.enclosingElement;
         setterUnit.replaceTopLevelVariable(setterVariable, variable);
         variable.setter = setter;
         (setter as PropertyAccessorElementImpl).variable = variable;
       }
     }
   }
 
   /**
-   * If the given [node] has a documentation comment, remember its range
-   * into the given [element].
+   * If the given [node] has a documentation comment, remember its content
+   * and range into the given [element].
    */
-  void _setDocRange(ElementImpl element, AnnotatedNode node) {
+  void _setDoc(ElementImpl element, AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null && comment.isDocumentation) {
+      element.documentationComment =
+          comment.tokens.map((Token t) => t.lexeme).join('\n');
       element.setDocRange(comment.offset, comment.length);
     }
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
@@ skipping 408 matching lines @@
     //
     // Record outputs.
     //
     outputs[INFERABLE_STATIC_VARIABLE_DEPENDENCIES] = gatherer.results.toList();
   }
 
   /**
    * Return `true` if the given [variable] is a static variable whose type
    * should be inferred.
    */
-  bool _isInferableStatic(VariableElement variable) => variable.isStatic &&
+  bool _isInferableStatic(VariableElement variable) =>
+      variable.isStatic &&
       variable.hasImplicitType &&
       variable.initializer != null;
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     if (target is VariableElement) {
@@ skipping 164 matching lines @@
     //
     outputs[PROPAGABLE_VARIABLE_DEPENDENCIES] = gatherer.results.toList();
   }
 
   /**
    * Return `true` if the given [variable] is a variable whose type can be
    * propagated.
    */
   bool _isPropagable(VariableElement variable) =>
       variable is PropertyInducingElement &&
-          (variable.isConst || variable.isFinal) &&
-          variable.hasImplicitType &&
-          variable.initializer != null;
+      (variable.isConst || variable.isFinal) &&
+      variable.hasImplicitType &&
+      variable.initializer != null;
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     if (target is VariableElement) {
       CompilationUnitElementImpl unit = target
           .getAncestor((Element element) => element is CompilationUnitElement);
@@ skipping 3242 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }