Fix summary handling of unresolved imports, exports, and parts.

pkg/analyzer/lib/src/generated/resolver.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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1900 matching lines @@
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     ExportElement exportElement = node.element;
-    if (exportElement != null && exportElement.uriExists) {
+    if (exportElement != null) {
       // The element is null when the URI is invalid
       LibraryElement library = exportElement.exportedLibrary;
-      if (library != null) {
+      if (library != null && !library.isSynthetic) {
         for (Combinator combinator in node.combinators) {
           _checkCombinator(exportElement.exportedLibrary, combinator);
         }
       }
     }
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
@@ skipping 20 matching lines @@
           return null;
         }
       }
     }
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     ImportElement importElement = node.element;
-    if (importElement != null && importElement.uriExists) {
+    if (importElement != null) {
       // The element is null when the URI is invalid, but not when the URI is
       // valid but refers to a non-existent file.
       LibraryElement library = importElement.importedLibrary;
-      if (library != null) {
+      if (library != null && !library.isSynthetic) {
         for (Combinator combinator in node.combinators) {
           _checkCombinator(library, combinator);
         }
       }
     }
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
@@ skipping 2465 matching lines @@
   void generateUnusedImportHints(ErrorReporter errorReporter) {
     int length = _unusedImports.length;
     for (int i = 0; i < length; i++) {
       ImportDirective unusedImport = _unusedImports[i];
       // Check that the imported URI exists and isn't dart:core
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         LibraryElement libraryElement = importElement.importedLibrary;
         if (libraryElement == null ||
             libraryElement.isDartCore ||
-            !importElement.uriExists) {
+            libraryElement.isSynthetic) {
           continue;
         }
       }
       errorReporter.reportErrorForNode(
           HintCode.UNUSED_IMPORT, unusedImport.uri);
     }
   }
 
   /**
    * Report an [HintCode.UNUSED_SHOWN_NAME] hint for each unused shown name.
@@ skipping 437 matching lines @@
   }
 
   /**
    * Clear the type information assocated with [node].
    */
   static void clearType(AstNode node) {
     node?.setProperty(_typeProperty, null);
   }
 
   /**
+   * Look for contextual type information attached to [node].  Returns
+   * the type if found, otherwise null.
+   *
+   * If [node] has a contextual union type like `T | Future<T>` this will be
+   * returned. You can use [getType] if you prefer to only get the `T`.
+   */
+  static DartType getContext(AstNode node) => node?.getProperty(_typeProperty);
+
+  /**
    * Look for a single contextual type attached to [node], and returns the type
    * if found, otherwise null.
    *
    * If [node] has a contextual union type like `T | Future<T>` this will
    * simplify it to only return `T`. If the caller can handle a union type,
    * [getContext] should be used instead.
    */
   static DartType getType(AstNode node) {
     DartType t = getContext(node);
     if (t is FutureUnionType) {
       return t.type;
     }
     return t;
   }
 
   /**
-   * Look for contextual type information attached to [node].  Returns
-   * the type if found, otherwise null.
-   *
-   * If [node] has a contextual union type like `T | Future<T>` this will be
-   * returned. You can use [getType] if you prefer to only get the `T`.
-   */
-  static DartType getContext(AstNode node) => node?.getProperty(_typeProperty);
-
-  /**
    * Like [getContext] but expands a union type into a list of types.
    */
   static Iterable<DartType> getTypes(AstNode node) {
     DartType t = getContext(node);
     if (t == null) {
       return DartType.EMPTY_LIST;
     }
     if (t is FutureUnionType) {
       return t.types;
     }
@@ skipping 6157 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }