Compute documentation offsets for library, import, and export directive elements (issue 24756)

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/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 794 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);
             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);
             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].
+   */
+  void _setDocRange(ElementImpl element, AnnotatedNode node) {
+    Comment comment = node.documentationComment;
+    if (comment != null && comment.isDocumentation) {
+      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) {
     Source source = target;
     return <String, TaskInput>{
       LIBRARY_INPUT: LIBRARY_ELEMENT1.of(source),
       UNIT_INPUT_NAME:
           RESOLVED_UNIT1.of(new LibrarySpecificUnit(source, source)),
@@ skipping 248 matching lines @@
         definingCompilationUnit.element;
     Map<Source, CompilationUnit> partUnitMap =
         new HashMap<Source, CompilationUnit>();
     for (CompilationUnit partUnit in partUnits) {
       Source partSource = partUnit.element.source;
       partUnitMap[partSource] = partUnit;
     }
     //
     // Update "part" directives.
     //
+    LibraryDirective libraryDirective = null;
     LibraryIdentifier libraryNameNode = null;
     String partsLibraryName = _UNKNOWN_LIBRARY_NAME;
     bool hasPartDirective = false;
     FunctionElement entryPoint =
         _findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = <Directive>[];
     List<CompilationUnitElementImpl> sourcedCompilationUnits =
         <CompilationUnitElementImpl>[];
     for (Directive directive in definingCompilationUnit.directives) {
       if (directive is LibraryDirective) {
-        if (libraryNameNode == null) {
+        if (libraryDirective == null) {
+          libraryDirective = directive;
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
         Source partSource = partDirective.source;
         hasPartDirective = true;
         CompilationUnit partUnit = partUnitMap[partSource];
         if (partUnit != null) {
@@ skipping 63 matching lines @@
         new LibraryElementImpl.forNode(owningContext, libraryNameNode);
     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);
+    }
     //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
     outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
   }
 
   /**
    * Add all of the non-synthetic [getters] and [setters] defined in the given
@@ skipping 66 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].
+   */
+  void _setDocRange(ElementImpl element, AnnotatedNode node) {
+    Comment comment = node.documentationComment;
+    if (comment != null && comment.isDocumentation) {
+      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) {
     Source source = target;
     return <String, TaskInput>{
       DEFINING_UNIT_INPUT:
           RESOLVED_UNIT1.of(new LibrarySpecificUnit(source, source)),
       PARTS_UNIT_INPUT: INCLUDED_PARTS.of(source).toList((Source unit) {
@@ skipping 764 matching lines @@
 
     //
     // Gather error filters.
     //
     List<ErrorFilter> filters =
         context.getConfigurationData(CONFIGURED_ERROR_FILTERS);
     for (ResultDescriptor result in enginePlugin.dartErrorsForUnit) {
       String inputName = result.name + '_input';
       Map<Source, List<AnalysisError>> errorMap = getRequiredInput(inputName);
       for (List<AnalysisError> errors in errorMap.values) {
-        errorLists.add(errors
-            .where((AnalysisError error) {
-              return !filters.any((ErrorFilter filter) => filter(error));
-            })
-            .toList());
+        errorLists.add(errors.where((AnalysisError error) {
+          return !filters.any((ErrorFilter filter) => filter(error));
+        }).toList());
       }
     }
     //
     // Record outputs.
     //
     outputs[DART_ERRORS] = AnalysisError.mergeLists(errorLists);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
@@ skipping 2613 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }