Use parsed unit/class nodes instead of resolved in fixes.

pkg/analysis_server/lib/src/services/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.
 
 library services.src.correction.util;
 
 import 'dart:math';
 
 import 'package:analysis_server/src/protocol.dart'
     show SourceChange, SourceEdit;
 import 'package:analysis_server/src/protocol_server.dart'
     show doSourceChange_addElementEdit;
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/strings.dart';
 import 'package:analysis_server/src/services/search/element_visitors.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:path/path.dart';
 
 /**
  * Adds edits to the given [change] that ensure that all the [libraries] are
  * imported into the given [targetLibrary].
  */
 void addLibraryImports(SourceChange change, LibraryElement targetLibrary,
     Set<LibraryElement> libraries) {
-  CompilationUnit libUnit = targetLibrary.definingCompilationUnit.node;
+  CompilationUnitElement libUnitElement = targetLibrary.definingCompilationUnit;
+  CompilationUnit libUnit = getParsedUnit(libUnitElement);
   // prepare new import location
   int offset = 0;
   String prefix;
   String suffix;
   {
     // if no directives
     prefix = '';
     CorrectionUtils libraryUtils = new CorrectionUtils(libUnit);
     String eol = libraryUtils.endOfLine;
     suffix = eol;
@@ skipping 65 matching lines @@
 String findAbsoluteUri(AnalysisContext context, String path) {
   Source fileSource = new NonExistingSource(path, UriKind.FILE_URI);
   Uri uri = context.sourceFactory.restoreUri(fileSource);
   if (uri == null) {
     return null;
   }
   return uri.toString();
 }
 
 /**
+ * Returns the EOL to use for the given [code].
+ */
+String getCodeEndOfLine(String code) {
+  if (code.contains('\r\n')) {
+    return '\r\n';
+  }
+  return '\n';
+}
+
+/**
  * TODO(scheglov) replace with nodes once there will be [CompilationUnit.getComments].
  *
  * Returns [SourceRange]s of all comments in [unit].
  */
 List<SourceRange> getCommentRanges(CompilationUnit unit) {
   List<SourceRange> ranges = <SourceRange>[];
   Token token = unit.beginToken;
   while (token != null && token.type != TokenType.EOF) {
     Token commentToken = token.precedingComments;
     while (commentToken != null) {
@@ skipping 286 matching lines @@
   AstNode current = node.parent;
   int index = numParents;
   while (current != null) {
     parents[--index] = current;
     current = current.parent;
   }
   return parents;
 }
 
 /**
+ * Returns a parsed [AstNode] for the given [classElement].
+ *
+ * The resulting AST structure may or may not be resolved.
+ */
+AstNode getParsedClassElementNode(ClassElement classElement) {
+  CompilationUnitElement unitElement =
+      classElement.getAncestor((e) => e is CompilationUnitElement);
+  CompilationUnit unit = getParsedUnit(unitElement);
+  int offset = classElement.nameOffset;
+  AstNode classNameNode = new NodeLocator.con1(offset).searchWithin(unit);
+  if (classElement.isEnum) {
+    return classNameNode.getAncestor((node) => node is EnumDeclaration);
+  } else {
+    return classNameNode.getAncestor(
+        (node) => node is ClassDeclaration || node is ClassTypeAlias);
+  }
+}
+
+/**
+ * Returns a parsed [CompilationUnit] for the given [unitElement].
+ *
+ * The resulting AST structure may or may not be resolved.
+ * If it is not resolved, then at least the given [unitElement] will be set.
+ */
+CompilationUnit getParsedUnit(CompilationUnitElement unitElement) {
+  AnalysisContext context = unitElement.context;
+  Source source = unitElement.source;
+  CompilationUnit unit = context.parseCompilationUnit(source);
+  if (unit.element == null) {
+    unit.element = unitElement;
+  }
+  return unit;
+}
+
+/**
  * Returns a [PropertyAccessorElement] if the given [SimpleIdentifier] is a
  * reference to a property, or `null` in the other case.
  */
 PropertyAccessorElement getPropertyAccessorElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is PropertyAccessorElement) {
     return element;
   }
   return null;
 }
@@ skipping 1078 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }