Catch and suppress expected exceptions in corrections.

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/plugin/protocol/protocol.dart'
     show SourceChange, SourceEdit;
@@ skipping 13 matching lines @@
 import 'package:analyzer/src/generated/resolver.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) {
-  CompilationUnitElement libUnitElement = targetLibrary.definingCompilationUnit;
-  CompilationUnit libUnit = getParsedUnit(libUnitElement);
-  CorrectionUtils libUtils = new CorrectionUtils(libUnit);
+  CorrectionUtils libUtils;
+  try {
+    CompilationUnitElement unitElement = targetLibrary.definingCompilationUnit;
+    CompilationUnit unitAst = getParsedUnit(unitElement);
+    libUtils = new CorrectionUtils(unitAst);
+  } catch (e) {
+    throw new CancelCorrectionException(exception: e);
+  }
   String eol = libUtils.endOfLine;
   // Prepare information about existing imports.
   LibraryDirective libraryDirective;
   List<_ImportDirectiveInfo> importDirectives = <_ImportDirectiveInfo>[];
-  for (Directive directive in libUnit.directives) {
+  for (Directive directive in libUtils.unit.directives) {
     if (directive is LibraryDirective) {
       libraryDirective = directive;
     } else if (directive is ImportDirective) {
       importDirectives.add(new _ImportDirectiveInfo(
           directive.uriContent, directive.offset, directive.end));
     }
   }
 
   // Prepare all URIs to import.
   List<String> uriList = libraries
@@ skipping 605 matching lines @@
   if (expression != null) {
     AstNode parent = expression.parent;
     if (parent is NamedExpression && parent.expression == expression) {
       return parent;
     }
   }
   return expression;
 }
 
 /**
+ * This exception is thrown to cancel the current correction operation,
+ * such as quick assist or quick fix because an inconsistency was detected.
+ * These inconsistencies may happen as a part of normal workflow, e.g. because
+ * a resource was deleted, or an analysis result was invalidated.
+ */
+class CancelCorrectionException {
+  final Object exception;
+  CancelCorrectionException({this.exception});
+}
+
+/**
  * Describes the location for a newly created [ClassMember].
  */
 class ClassMemberLocation {
   final String prefix;
   final int offset;
   final String suffix;
 
   ClassMemberLocation(this.prefix, this.offset, this.suffix);
 }
 
 class CorrectionUtils {
   final CompilationUnit unit;
 
   /**
    * The [ClassElement] the generated code is inserted to, so we can decide if
    * a type parameter may or may not be used.
    */
   ClassElement targetClassElement;
 
   LibraryElement _library;
   String _buffer;
   String _endOfLine;
 
   CorrectionUtils(this.unit) {
     CompilationUnitElement unitElement = unit.element;
+    AnalysisContext context = unitElement.context;
+    if (context == null) {
+      throw new CancelCorrectionException();

[Brian Wilkerson, 2016/10/05 13:52:20]

How often does this occur? Should we log the issue rather than hiding it?

+    }
     this._library = unitElement.library;
-    this._buffer = unitElement.context.getContents(unitElement.source).data;
+    this._buffer = context.getContents(unitElement.source).data;
   }
 
   /**
    * Returns the EOL to use for this [CompilationUnit].
    */
   String get endOfLine {
     if (_endOfLine == null) {
       if (_buffer.contains("\r\n")) {
         _endOfLine = "\r\n";
       } else {
@@ skipping 927 matching lines @@
       _InvertedCondition expr, int newOperatorPrecedence) {
     if (expr._precedence < newOperatorPrecedence) {
       return "(${expr._source})";
     }
     return expr._source;
   }
 
   static _InvertedCondition _simple(String source) =>
       new _InvertedCondition(2147483647, source);
 }