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

[Brian Wilkerson, 2016/08/11 23:49:35]

Seems odd to talk about setting a getter to `true`. :-)

I haven't thought about it very hard, but it also seems strange to make this
abstract when most of the overrides are "return false". Seems like it would be
easier to subclass this class if it just returned `false`, or was a field
initialized to `false`, but you probably had a reason for not doing that.

[Paul Berry, 2016/08/12 20:56:51]

Resolved in an offline discussion.  There was a slight complication due to a
strong mode error (a getter can't override a field, even if the getter is
abstract).  I've worked around that problem and made a request to see if we can
loosen the strong mode restriction.

+   * summary resynthesis shouldn't trigger an error.
+   */
+  bool get allowMissingFiles;
+
   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
+  bool allowMissingFiles = false;
+
+  @override
   LibraryElementImpl checkLibrary(String text,
       {bool allowErrors: false, bool dumpSummaries: false}) {
     Source source = addTestSource(text);
     LibraryElementImpl original = context.computeLibraryElement(source);
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
         encodeLibrary(original,
             allowErrors: allowErrors, dumpSummaries: dumpSummaries),
         source.uri.toString(),
         original);
     checkLibraryElements(original, resynthesized);
@@ skipping 55 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 11 matching lines @@
     LibraryElementImpl original =
         context.computeLibraryElement(context.sourceFactory.forUri(uri));
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
         encodeLibraryElement(original), uri, original);
     checkLibraryElements(original, resynthesized);
   }
 }
 
 @reflectiveTest
 abstract class ResynthesizeTest extends AbstractResynthesizeTest {
+  /**
+   * Tests may set this to `true` to indicate that a missing file at the time of
+   * summary resynthesis shouldn't trigger an error.
+   */
+  void set allowMissingFiles(bool value);
+
   LibraryElementImpl checkLibrary(String text,
       {bool allowErrors: false, bool dumpSummaries: false});
 
   /**
    * Return a [SummaryResynthesizer] to resynthesize the library with the
    * given [librarySource].
    */
   SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource);
 
   fail_library_hasExtUri() {
@@ skipping 3002 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;
   }
 }