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

pkg/analyzer/test/src/summary/resynthesize_test.dart

 // Copyright (c) 2015, 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 test.src.serialization.elements_test;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
@@ skipping 31 matching lines @@
  */
 abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
   Set<Source> otherLibrarySources = new Set<Source>();
 
   /**
    * Names of variables which have initializers that are not valid constants,
    * so they are not resynthesized.
    */
   Set<String> variablesWithNotConstInitializers = new Set<String>();
 
+  /**
+   * Tests may set this to `true` to indicate that a missing file at the time of
+   * summary resynthesis shouldn't trigger an error.
+   */
+  bool allowMissingFiles = false;
+
   bool get checkPropagatedTypes => true;
 
   void addLibrary(String uri) {
     otherLibrarySources.add(context.sourceFactory.forUri(uri));
   }
 
   Source addLibrarySource(String filePath, String contents) {
     Source source = addSource(filePath, contents);
     otherLibrarySources.add(source);
     return source;
@@ skipping 1115 matching lines @@
     }
     if (dumpSummaries) {
       unlinkedSummaries.forEach((String path, UnlinkedUnit unit) {
         print('Unlinked $path: ${JSON.encode(canonicalize(unit))}');
       });
       linkedSummaries.forEach((String path, LinkedLibrary lib) {
         print('Linked $path: ${JSON.encode(canonicalize(lib))}');
       });
     }
     return new TestSummaryResynthesizer(
-        null, context, unlinkedSummaries, linkedSummaries);
+        null, context, unlinkedSummaries, linkedSummaries, allowMissingFiles);
   }
 
   ElementImpl getActualElement(Element element, String desc) {
     if (element == null) {
       return null;
     } else if (element is ElementImpl) {
       return element;
     } else if (element is ElementHandle) {
       Element actualElement = element.actualElement;
       // A handle should never point to a member, because if it did, then
@@ skipping 126 matching lines @@
         return element.isSetter;
       }
       return false;
     } else if (modifier == Modifier.STATIC) {
       if (element is ExecutableElement) {
         return element.isStatic;
       }
       return false;
     } else if (modifier == Modifier.SYNTHETIC) {
       return element.isSynthetic;
-    } else if (modifier == Modifier.URI_EXISTS) {
-      if (element is ExportElement) {
-        return element.uriExists;
-      } else if (element is ImportElement) {
-        return element.uriExists;
-      }
-      return false;
     }
     throw new UnimplementedError(
         'Modifier $modifier for ${element?.runtimeType}');
   }
 }
 
 @reflectiveTest
 class ResynthesizeElementTest extends ResynthesizeTest {
   @override
   LibraryElementImpl checkLibrary(String text,
@@ skipping 64 matching lines @@
     }
     if (dumpSummaries) {
       unlinkedSummaries.forEach((String path, UnlinkedUnit unit) {
         print('Unlinked $path: ${JSON.encode(canonicalize(unit))}');
       });
       linkedSummaries.forEach((String path, LinkedLibrary lib) {
         print('Linked $path: ${JSON.encode(canonicalize(lib))}');
       });
     }
     return new TestSummaryResynthesizer(
-        null, context, unlinkedSummaries, linkedSummaries);
+        null, context, unlinkedSummaries, linkedSummaries, allowMissingFiles);
   }
 
   /**
    * Resynthesize the library element associated with [uri] using
    * [resynthesizer], and verify that it only had to consult one summary in
    * order to do so.  [original] is consulted merely to verify that no
    * unnecessary resynthesis work was performed.
    */
   LibraryElementImpl resynthesizeLibraryElement(
       TestSummaryResynthesizer resynthesizer,
@@ skipping 3033 matching lines @@
   }
 
   test_typedef_type_parameters_f_bound_simple() {
     checkLibrary('typedef U F<T extends U, U>(T t);');
   }
 
   test_typedefs() {
     checkLibrary('f() {} g() {}');
   }
 
+  test_unresolved_export() {
+    allowMissingFiles = true;
+    checkLibrary("export 'foo.dart';", allowErrors: true);
+  }
+
+  test_unresolved_import() {
+    allowMissingFiles = true;
+    checkLibrary("import 'foo.dart';", allowErrors: true);
+  }
+
+  test_unresolved_part() {
+    allowMissingFiles = true;
+    checkLibrary("part 'foo.dart';", allowErrors: true);
+  }
+
   test_unused_type_parameter() {
     checkLibrary('''
 class C<T> {
   void f() {}
 }
 C<int> c;
 var v = c.f;
 ''');
   }
 
@@ skipping 92 matching lines @@
     // the library element.
     expect(resynthesizer.resynthesisCount, 1);
     expect(result.location, location);
     return result;
   }
 }
 
 class TestSummaryResynthesizer extends SummaryResynthesizer {
   final Map<String, UnlinkedUnit> unlinkedSummaries;
   final Map<String, LinkedLibrary> linkedSummaries;
+  final bool allowMissingFiles;
 
   /**
    * The set of uris for which unlinked summaries have been requested using
    * [getUnlinkedSummary].
    */
   final Set<String> unlinkedSummariesRequested = new Set<String>();
 
   /**
    * The set of uris for which linked summaries have been requested using
    * [getLinkedSummary].
    */
   final Set<String> linkedSummariesRequested = new Set<String>();
 
   TestSummaryResynthesizer(SummaryResynthesizer parent, AnalysisContext context,
-      this.unlinkedSummaries, this.linkedSummaries)
+      this.unlinkedSummaries, this.linkedSummaries, this.allowMissingFiles)
       : super(parent, context, context.typeProvider, context.sourceFactory,
             context.analysisOptions.strongMode);
 
   @override
   LinkedLibrary getLinkedSummary(String uri) {
     linkedSummariesRequested.add(uri);
     LinkedLibrary serializedLibrary = linkedSummaries[uri];
-    if (serializedLibrary == null) {
+    if (serializedLibrary == null && !allowMissingFiles) {
       fail('Unexpectedly tried to get linked summary for $uri');
     }
     return serializedLibrary;
   }
 
   @override
   UnlinkedUnit getUnlinkedSummary(String uri) {
     unlinkedSummariesRequested.add(uri);
     UnlinkedUnit serializedUnit = unlinkedSummaries[uri];
-    if (serializedUnit == null) {
+    if (serializedUnit == null && !allowMissingFiles) {
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }