Uncomment and test fixes for importing libraries.

pkg/analysis_services/lib/src/correction/util.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library services.src.correction.util;
 
 import 'package:analysis_services/src/correction/source_range.dart';
@@ skipping 40 matching lines @@
     if (node is MethodDeclaration) {
       return node.element;
     }
     node = node.parent;
   }
   return null;
 }
 
 
 /**
+ * Returns a namespace of the given [ExportElement].
+ */
+Map<String, Element> getExportNamespace(ExportElement exp) {
+  Namespace namespace =
+      new NamespaceBuilder().createExportNamespaceForDirective(exp);
+  return namespace.definedNames;
+}
+
+
+/**
+ * Returns a export namespace of the given [LibraryElement].
+ */
+Map<String, Element> getExportNamespace2(LibraryElement library) {

[Brian Wilkerson, 2014/07/28 18:06:56]

How about getExportNamespaceForDirective and getExportNamespaceForLibrary rather
than getExportNamespace and getExportNamespace2?

[scheglov, 2014/07/28 18:27:28]

Done.

+  Namespace namespace =
+      new NamespaceBuilder().createExportNamespaceForLibrary(library);
+  return namespace.definedNames;
+}
+
+
+/**
+ * Returns an [Element] exported from the given [LibraryElement].
+ */
+Element getExportedElement(LibraryElement library, String name) {
+  if (library == null) {
+    return null;
+  }
+  return getExportNamespace2(library)[name];
+}
+
+/**
  * Returns [getExpressionPrecedence] for the parent of [node],
  * or `0` if the parent node is [ParenthesizedExpression].
  *
  * The reason is that `(expr)` is always executed after `expr`.
  */
 int getExpressionParentPrecedence(AstNode node) {
   AstNode parent = node.parent;
   if (parent is ParenthesizedExpression) {
     return 0;
   }
   return getExpressionPrecedence(parent);
 }
 
 
 /**
  * Returns the precedence of [node] it is an [Expression], negative otherwise.
  */
 int getExpressionPrecedence(AstNode node) {
   if (node is Expression) {
     return node.precedence;
   }
   return -1000;
 }
 
-
 /**
  * Returns the namespace of the given [ImportElement].
  */
 Map<String, Element> getImportNamespace(ImportElement imp) {
   NamespaceBuilder builder = new NamespaceBuilder();
   Namespace namespace = builder.createImportNamespaceForDirective(imp);
   return namespace.definedNames;
 }
 
 /**
@@ skipping 10 matching lines @@
   }
   if (parent is PropertyAccess) {
     PropertyAccess access = parent;
     if (identical(access.propertyName, node)) {
       return access.realTarget;
     }
   }
   return null;
 }
 
-
 /**
  * Returns the [String] content of the given [Source].
  */
 String getSourceContent(AnalysisContext context, Source source) {
   return context.getContents(source).data;
 }
 
 class CorrectionUtils {
   final CompilationUnit unit;
 
@@ skipping 190 matching lines @@
   /**
    * Returns the line prefix consisting of spaces and tabs on the left from the
    * given offset.
    */
   String getPrefix(int endIndex) {
     int startIndex = getLineContentStart(endIndex);
     return _buffer.substring(startIndex, endIndex);
   }
 
   /**
+   * Returns a [InsertDesc] describing where to insert a new library-related
+   * directive.
+   */
+  CorrectionUtils_InsertDesc get insertDescImport {

[Brian Wilkerson, 2014/07/28 18:06:56]

These getters look like they could take a while. I think the general philosophy
is that getters should be used only when they are about as fast as a field
access, and that methods should be used when they take longer than that. But I
leave it to you to decide.

[scheglov, 2014/07/28 18:27:28]

Thank you, fixed.

+    // analyze directives
+    Directive prevDirective = null;
+    for (Directive directive in unit.directives) {
+      if (directive is LibraryDirective || directive is ImportDirective || directive is ExportDirective) {
+        prevDirective = directive;
+      }
+    }
+    // insert after last library-related directive
+    if (prevDirective != null) {
+      CorrectionUtils_InsertDesc result = new CorrectionUtils_InsertDesc();
+      result.offset = prevDirective.end;
+      String eol = endOfLine;
+      if (prevDirective is LibraryDirective) {
+        result.prefix = "${eol}${eol}";
+      } else {
+        result.prefix = eol;
+      }
+      return result;
+    }
+    // no directives, use "top" location
+    return insertDescTop;
+  }
+
+  /**
+   * Returns a [InsertDesc] describing where to insert a new 'part' directive.
+   */
+  CorrectionUtils_InsertDesc get insertDescPart {
+    // analyze directives
+    Directive prevDirective = null;
+    for (Directive directive in unit.directives) {
+      prevDirective = directive;
+    }
+    // insert after last directive
+    if (prevDirective != null) {
+      CorrectionUtils_InsertDesc result = new CorrectionUtils_InsertDesc();
+      result.offset = prevDirective.end;
+      String eol = endOfLine;
+      if (prevDirective is PartDirective) {
+        result.prefix = eol;
+      } else {
+        result.prefix = "${eol}${eol}";
+      }
+      return result;
+    }
+    // no directives, use "top" location
+    return insertDescTop;
+  }
+
+  /**
+   * Returns a [InsertDesc] describing where to insert a new directive or a
+   * top-level declaration at the top of the file.
+   */
+  CorrectionUtils_InsertDesc get insertDescTop {
+    // skip leading line comments
+    int offset = 0;
+    bool insertEmptyLineBefore = false;
+    bool insertEmptyLineAfter = false;
+    String source = _buffer;
+    // skip hash-bang
+    if (offset < source.length - 2) {
+      String linePrefix = getText2(offset, 2);
+      if (linePrefix == "#!") {
+        insertEmptyLineBefore = true;
+        offset = getLineNext(offset);
+        // skip empty lines to first line comment
+        int emptyOffset = offset;
+        while (emptyOffset < source.length - 2) {
+          int nextLineOffset = getLineNext(emptyOffset);
+          String line = source.substring(emptyOffset, nextLineOffset);
+          if (line.trim().isEmpty) {
+            emptyOffset = nextLineOffset;
+            continue;
+          } else if (line.startsWith("//")) {
+            offset = emptyOffset;
+            break;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+    // skip line comments
+    while (offset < source.length - 2) {
+      String linePrefix = getText2(offset, 2);
+      if (linePrefix == "//") {
+        insertEmptyLineBefore = true;
+        offset = getLineNext(offset);
+      } else {
+        break;
+      }
+    }
+    // determine if empty line is required after
+    int nextLineOffset = getLineNext(offset);
+    String insertLine = source.substring(offset, nextLineOffset);
+    if (!insertLine.trim().isEmpty) {
+      insertEmptyLineAfter = true;
+    }
+    // fill InsertDesc
+    CorrectionUtils_InsertDesc desc = new CorrectionUtils_InsertDesc();
+    desc.offset = offset;
+    if (insertEmptyLineBefore) {
+      desc.prefix = endOfLine;
+    }
+    if (insertEmptyLineAfter) {
+      desc.suffix = endOfLine;
+    }
+    return desc;
+  }
+
+  /**
+   * Returns a start index of the next line after the line which contains the
+   * given index.
+   */
+  int getLineNext(int index) {
+    int length = _buffer.length;
+    // skip to the end of the line
+    while (index < length) {
+      int c = _buffer.codeUnitAt(index);
+      if (c == 0xD || c == 0xA) {
+        break;
+      }
+      index++;
+    }
+    // skip single \r
+    if (index < length && _buffer.codeUnitAt(index) == 0xD) {
+      index++;
+    }
+    // skip single \n
+    if (index < length && _buffer.codeUnitAt(index) == 0xA) {
+      index++;
+    }
+    // done
+    return index;
+  }
+
+  /**
    * Returns the text of the given [AstNode] in the unit.
    */
   String getText(AstNode node) => getText2(node.offset, node.length);
 
   /**
    * Returns the text of the given range in the unit.
    */
   String getText2(int offset, int length) =>
       _buffer.substring(offset, offset + length);
 
@@ skipping 57 matching lines @@
   ImportElement _getImportElement(Element element) {
     for (ImportElement imp in _library.imports) {
       Map<String, Element> definedNames = getImportNamespace(imp);
       if (definedNames.containsValue(element)) {
         return imp;
       }
     }
     return null;
   }
 }
+
+
+/**
+ * Describes where to insert new directive or top-level declaration.
+ */
+class CorrectionUtils_InsertDesc {
+  int offset = 0;
+  String prefix = "";
+  String suffix = "";
+}