Fix for sorting directives with documentation comments.

pkg/analysis_server/lib/src/services/correction/sort_members.dart

 // Copyright (c) 2014, 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 services.src.refactoring.sort_members;
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/services/correction/strings.dart';
 import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/token.dart';
 
 /**
  * Sorter for unit/class members.
  */
 class MemberSorter {
   static List<_PriorityItem> _PRIORITY_ITEMS = [
     new _PriorityItem(false, _MemberKind.UNIT_FUNCTION_MAIN, false),
     new _PriorityItem(false, _MemberKind.UNIT_VARIABLE_CONST, false),
     new _PriorityItem(false, _MemberKind.UNIT_VARIABLE_CONST, true),
     new _PriorityItem(false, _MemberKind.UNIT_VARIABLE, false),
@@ skipping 133 matching lines @@
       }
     }
     // do sort
     _sortAndReorderMembers(members);
   }
 
   /**
    * Sorts all [Directive]s.
    */
   void _sortUnitDirectives() {
+    bool hasLibraryDirective = false;
     List<_DirectiveInfo> directives = [];
     for (Directive directive in unit.directives) {
+      if (directive is LibraryDirective) {
+        hasLibraryDirective = true;
+      }
       if (directive is! UriBasedDirective) {
         continue;
       }
       UriBasedDirective uriDirective = directive as UriBasedDirective;
       String uriContent = uriDirective.uri.stringValue;
       _DirectivePriority kind = null;
       if (directive is ImportDirective) {
         if (uriContent.startsWith("dart:")) {
           kind = _DirectivePriority.IMPORT_SDK;
         } else if (uriContent.startsWith("package:")) {
@@ skipping 12 matching lines @@
         } else if (uriContent.contains('://')) {
           kind = _DirectivePriority.EXPORT_OTHER;
         } else {
           kind = _DirectivePriority.EXPORT_REL;
         }
       }
       if (directive is PartDirective) {
         kind = _DirectivePriority.PART;
       }
       if (kind != null) {
-        int offset = directive.offset;
-        int length = directive.length;
+        String documentationText;
+        if (directive.documentationComment != null) {
+          documentationText = code.substring(
+              directive.documentationComment.offset,
+              directive.documentationComment.end);
+        }
+        int offset = directive.firstTokenAfterCommentAndMetadata.offset;
+        int length = directive.end - offset;
         String text = code.substring(offset, offset + length);
-        directives.add(new _DirectiveInfo(directive, kind, uriContent, text));
+        directives.add(new _DirectiveInfo(
+            directive, kind, uriContent, documentationText, text));
       }
     }
     // nothing to do
     if (directives.isEmpty) {
       return;
     }
     int firstDirectiveOffset = directives[0].directive.offset;
     int lastDirectiveEnd = directives[directives.length - 1].directive.end;
+    // Without a library directive, the library comment is the comment of the
+    // first directive.
+    _DirectiveInfo libraryDocumentationDirective;
+    if (!hasLibraryDirective && directives.isNotEmpty) {
+      libraryDocumentationDirective = directives.first;
+    }
     // do sort
     directives.sort();
     // append directives with grouping
     String directivesCode;
     {
       StringBuffer sb = new StringBuffer();
       String endOfLine = this.endOfLine;
       _DirectivePriority currentPriority = null;
+      bool firstOutputDirective = true;
       for (_DirectiveInfo directive in directives) {
         if (currentPriority != directive.priority) {
           if (sb.length != 0) {
             sb.write(endOfLine);
           }
           currentPriority = directive.priority;
         }
+        if (directive != libraryDocumentationDirective &&
+            directive.documentationText != null) {
+          sb.write(directive.documentationText);
+          sb.write(endOfLine);
+        }
+        if (firstOutputDirective) {
+          firstOutputDirective = false;
+          if (libraryDocumentationDirective != null &&
+              libraryDocumentationDirective.documentationText != null) {
+            sb.write(libraryDocumentationDirective.documentationText);
+            sb.write(endOfLine);
+          }
+        }
         sb.write(directive.text);
         sb.write(endOfLine);
       }
       directivesCode = sb.toString();
       directivesCode = directivesCode.trimRight();
     }
-    // append comment tokens which otherwise would be removed completely
-    {
-      bool firstCommentToken = true;
-      Token token = unit.beginToken;
-      while (token != null &&
-          token.type != TokenType.EOF &&
-          token.end < lastDirectiveEnd) {
-        Token commentToken = token.precedingComments;
-        while (commentToken != null) {
-          int offset = commentToken.offset;
-          int end = commentToken.end;
-          if (offset > firstDirectiveOffset && offset < lastDirectiveEnd) {
-            if (firstCommentToken) {
-              directivesCode += endOfLine;
-              firstCommentToken = false;
-            }
-            directivesCode += code.substring(offset, end) + endOfLine;
-          }
-          commentToken = commentToken.next;
-        }
-        token = token.next;
-      }
-    }
     // prepare code
     String beforeDirectives = code.substring(0, firstDirectiveOffset);
     String afterDirectives = code.substring(lastDirectiveEnd);
     code = beforeDirectives + directivesCode + afterDirectives;
   }
 
   /**
    * Sorts all [CompilationUnitMember]s.
    */
   void _sortUnitMembers() {
@@ skipping 97 matching lines @@
       return priority1 - priority2;
     });
     return membersSorted;
   }
 }
 
 class _DirectiveInfo implements Comparable<_DirectiveInfo> {
   final Directive directive;
   final _DirectivePriority priority;
   final String uri;
+  final String documentationText;
   final String text;
 
-  _DirectiveInfo(this.directive, this.priority, this.uri, this.text);
+  _DirectiveInfo(this.directive, this.priority, this.uri,
+      this.documentationText, this.text);
 
   @override
   int compareTo(_DirectiveInfo other) {
     if (priority == other.priority) {
       return _compareUri(uri, other.uri);
     }
     return priority.ordinal - other.priority.ordinal;
   }
 
   @override
@@ skipping 101 matching lines @@
       return other.kind == kind && other.isStatic == isStatic;
     }
     return other.kind == kind &&
         other.isPrivate == isPrivate &&
         other.isStatic == isStatic;
   }
 
   @override
   String toString() => kind.toString();
 }