Use AbstractSingleUnitTest, so MockSdk in resynthesize tests.

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';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart'
     show Namespace, TypeProvider;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/resynthesize.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:unittest/unittest.dart';
 
-import '../../generated/resolver_test_case.dart';
+import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
+import '../abstract_single_unit.dart';
 import 'summary_common.dart' show canonicalize;
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ResynthTest);
 }
 
 @reflectiveTest
-class ResynthTest extends ResolverTestCase {
+class ResynthTest extends AbstractSingleUnitTest {
   Set<Source> otherLibrarySources = new Set<Source>();
   bool constantInitializersAreInvalid = false;
 
   void addLibrary(String uri) {
-    otherLibrarySources.add(analysisContext2.sourceFactory.forUri(uri));
+    otherLibrarySources.add(context.sourceFactory.forUri(uri));
   }
 
   void addLibrarySource(String filePath, String contents) {
-    otherLibrarySources.add(addNamedSource(filePath, contents));
+    otherLibrarySources.add(addSource(filePath, contents));
+  }
+
+  void assertNoErrors(Source source) {
+    GatheringErrorListener errorListener = new GatheringErrorListener();
+    for (AnalysisError error in context.computeErrors(source)) {
+      expect(error.source, source);
+      ErrorCode errorCode = error.errorCode;
+      if (errorCode == HintCode.UNUSED_ELEMENT ||
+          errorCode == HintCode.UNUSED_FIELD) {
+        continue;
+      }
+      if (errorCode == HintCode.UNUSED_CATCH_CLAUSE ||
+          errorCode == HintCode.UNUSED_CATCH_STACK ||
+          errorCode == HintCode.UNUSED_LOCAL_VARIABLE) {
+        continue;
+      }
+      errorListener.onError(error);
+    }
+    errorListener.assertNoErrors();
   }
 
   /**
    * Verify that the given prefix is safe to elide from a resynthesized AST.
    */
   void checkElidablePrefix(SimpleIdentifier prefix) {
     if (prefix.staticElement is! PrefixElement &&
         prefix.staticElement is! ClassElement) {
       fail('Prefix of type ${prefix.staticElement.runtimeType}'
           ' should not have been elided');
     }
   }
 
   void checkLibrary(String text,
       {bool allowErrors: false, bool dumpSummaries: false}) {
-    Source source = addSource(text);
-    LibraryElementImpl original = resolve2(source);
+    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);
   }
 
   void checkLibraryElements(
       LibraryElementImpl original, LibraryElementImpl resynthesized) {
@@ skipping 961 matching lines @@
    * references it makes to `dart:core`.
    *
    * Errors will lead to a test failure unless [allowErrors] is `true`.
    */
   _TestSummaryResynthesizer encodeLibrary(LibraryElementImpl library,
       {bool allowErrors: false, bool dumpSummaries: false}) {
     if (!allowErrors) {
       assertNoErrors(library.source);
     }
     addLibrary('dart:core');
+    addLibrary('dart:async');
+    addLibrary('dart:math');
     return encodeLibraryElement(library, dumpSummaries: dumpSummaries);
   }
 
   /**
    * Convert the library element [library] into a summary, and then create a
    * [_TestSummaryResynthesizer] which can deserialize it.
    *
    * Caller is responsible for checking the library for errors, and adding any
    * dependent libraries using [addLibrary].
    */
   _TestSummaryResynthesizer encodeLibraryElement(LibraryElementImpl library,
       {bool dumpSummaries: false}) {
     Map<String, UnlinkedUnit> unlinkedSummaries = <String, UnlinkedUnit>{};
     LinkedLibrary getLinkedSummaryFor(LibraryElement lib) {
       LibrarySerializationResult serialized = serializeLibrary(
-          lib, typeProvider, analysisContext.analysisOptions.strongMode);
+          lib, context.typeProvider, context.analysisOptions.strongMode);
       for (int i = 0; i < serialized.unlinkedUnits.length; i++) {
         unlinkedSummaries[serialized.unitUris[i]] =
             new UnlinkedUnit.fromBuffer(serialized.unlinkedUnits[i].toBuffer());
       }
       return new LinkedLibrary.fromBuffer(serialized.linked.toBuffer());
     }
     Map<String, LinkedLibrary> linkedSummaries = <String, LinkedLibrary>{
       library.source.uri.toString(): getLinkedSummaryFor(library)
     };
     for (Source source in otherLibrarySources) {
-      LibraryElement original = resolve2(source);
+      LibraryElement original = context.computeLibraryElement(source);
       String uri = source.uri.toString();
       linkedSummaries[uri] = getLinkedSummaryFor(original);
     }
     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,
-        analysisContext,
-        analysisContext.typeProvider,
-        analysisContext.sourceFactory,
+        context,
+        context.typeProvider,
+        context.sourceFactory,
         unlinkedSummaries,
         linkedSummaries,
         createOptions().strongMode);
   }
 
   fail_library_hasExtUri() {
     checkLibrary('import "dart-ext:doesNotExist.dart";');
   }
 
   ElementImpl getActualElement(Element element, String desc) {
@@ skipping 27 matching lines @@
       String uri,
       LibraryElement original) {
     LibraryElementImpl resynthesized = resynthesizer.getLibraryElement(uri);
     checkMinimalResynthesisWork(resynthesizer, original);
     return resynthesized;
   }
 
   @override
   void setUp() {
     super.setUp();
-    resetWithOptions(createOptions());
+    prepareAnalysisContext(createOptions());
   }
 
   test_class_abstract() {
     checkLibrary('abstract class C {}');
   }
 
   test_class_alias() {
     checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
   }
 
@@ skipping 1386 matching lines @@
   C() : x = new D();
 }
 class D {
   final x;
   D() : x = new C();
 }
 ''');
   }
 
   test_core() {
-    if (createOptions().strongMode) {
-      // The fake `dart:core` library is always in spec mode, so don't bother
-      // trying to check that it resynthesizes properly; it won't.
-      return;
-    }
+    addLibrary('dart:async');
+    addLibrary('dart:math');
     String uri = 'dart:core';
     LibraryElementImpl original =
-        resolve2(analysisContext2.sourceFactory.forUri(uri));
+        context.computeLibraryElement(context.sourceFactory.forUri(uri));
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
         encodeLibraryElement(original), uri, original);
     checkLibraryElements(original, resynthesized);
   }
 
   test_enum_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
@@ skipping 135 matching lines @@
   test_field_propagatedType_final_dep_inLib() {
     addLibrarySource('/a.dart', 'final a = 1;');
     checkLibrary('''
 import "a.dart";
 class C {
   final b = a / 2;
 }''');
   }
 
   test_field_propagatedType_final_dep_inPart() {
-    addNamedSource('/a.dart', 'part of lib; final a = 1;');
+    addSource('/a.dart', 'part of lib; final a = 1;');
     checkLibrary('''
 library lib;
 part "a.dart";
 class C {
   final b = a / 2;
 }''');
   }
 
   test_field_propagatedType_final_noDep_instance() {
     checkLibrary('''
@@ skipping 26 matching lines @@
     addLibrarySource('/a.dart', 'library a; main() {}');
     checkLibrary('export "a.dart";');
   }
 
   test_function_entry_point_in_export_hidden() {
     addLibrarySource('/a.dart', 'library a; main() {}');
     checkLibrary('export "a.dart" hide main;');
   }
 
   test_function_entry_point_in_part() {
-    addNamedSource('/a.dart', 'part of my.lib; main() {}');
+    addSource('/a.dart', 'part of my.lib; main() {}');
     checkLibrary('library my.lib; part "a.dart";');
   }
 
   test_function_external() {
     checkLibrary('external f();');
   }
 
   test_function_parameter_kind_named() {
     checkLibrary('f({x}) {}');
   }
@@ skipping 32 matching lines @@
 
   test_function_return_type_implicit() {
     checkLibrary('f() => null;');
   }
 
   test_function_return_type_void() {
     checkLibrary('void f() {}');
   }
 
   test_function_type_parameter() {
-    resetWithOptions(createOptions()..enableGenericMethods = true);
+    prepareAnalysisContext(createOptions()..enableGenericMethods = true);
     checkLibrary('T f<T, U>(U u) => null;');
   }
 
   test_function_type_parameter_with_function_typed_parameter() {
-    resetWithOptions(createOptions()..enableGenericMethods = true);
+    prepareAnalysisContext(createOptions()..enableGenericMethods = true);
     checkLibrary('void f<T, U>(T x(U u)) {}');
   }
 
   test_functions() {
     checkLibrary('f() {} g() {}');
   }
 
   test_generic_gClass_gMethodStatic() {
-    resetWithOptions(createOptions()..enableGenericMethods = true);
+    prepareAnalysisContext(createOptions()..enableGenericMethods = true);
     checkLibrary('''
 class C<T, U> {
   static void m<V, W>(V v, W w) {
     void f<X, Y>(V v, W w, X x, Y y) {
     }
   }
 }
 ''');
   }
 
   test_getElement_constructor_named() {
-    ConstructorElement original = resolve2(addSource('class C { C.named(); }'))
+    ConstructorElement original = context
+        .computeLibraryElement(addTestSource('class C { C.named(); }'))
         .getType('C')
         .getNamedConstructor('named');
     expect(original, isNotNull);
     ConstructorElement resynthesized = validateGetElement(original);
     compareConstructorElements(resynthesized, original, 'C.constructor named');
   }
 
   test_getElement_constructor_unnamed() {
-    ConstructorElement original =
-        resolve2(addSource('class C { C(); }')).getType('C').unnamedConstructor;
+    ConstructorElement original = context
+        .computeLibraryElement(addTestSource('class C { C(); }'))
+        .getType('C')
+        .unnamedConstructor;
     expect(original, isNotNull);
     ConstructorElement resynthesized = validateGetElement(original);
     compareConstructorElements(resynthesized, original, 'C.constructor');
   }
 
   test_getElement_field() {
-    FieldElement original =
-        resolve2(addSource('class C { var f; }')).getType('C').getField('f');
+    FieldElement original = context
+        .computeLibraryElement(addTestSource('class C { var f; }'))
+        .getType('C')
+        .getField('f');
     expect(original, isNotNull);
     FieldElement resynthesized = validateGetElement(original);
     compareFieldElements(resynthesized, original, 'C.field f');
   }
 
   test_getElement_getter() {
-    PropertyAccessorElement original =
-        resolve2(addSource('class C { get f => null; }'))
-            .getType('C')
-            .getGetter('f');
+    PropertyAccessorElement original = context
+        .computeLibraryElement(addTestSource('class C { get f => null; }'))
+        .getType('C')
+        .getGetter('f');
     expect(original, isNotNull);
     PropertyAccessorElement resynthesized = validateGetElement(original);
     comparePropertyAccessorElements(resynthesized, original, 'C.getter f');
   }
 
   test_getElement_method() {
-    MethodElement original =
-        resolve2(addSource('class C { f() {} }')).getType('C').getMethod('f');
+    MethodElement original = context
+        .computeLibraryElement(addTestSource('class C { f() {} }'))
+        .getType('C')
+        .getMethod('f');
     expect(original, isNotNull);
     MethodElement resynthesized = validateGetElement(original);
     compareMethodElements(resynthesized, original, 'C.method f');
   }
 
   test_getElement_operator() {
-    MethodElement original =
-        resolve2(addSource('class C { operator+(x) => null; }'))
-            .getType('C')
-            .getMethod('+');
+    MethodElement original = context
+        .computeLibraryElement(
+            addTestSource('class C { operator+(x) => null; }'))
+        .getType('C')
+        .getMethod('+');
     expect(original, isNotNull);
     MethodElement resynthesized = validateGetElement(original);
     compareMethodElements(resynthesized, original, 'C.operator+');
   }
 
   test_getElement_setter() {
-    PropertyAccessorElement original =
-        resolve2(addSource('class C { void set f(value) {} }'))
-            .getType('C')
-            .getSetter('f');
+    PropertyAccessorElement original = context
+        .computeLibraryElement(
+            addTestSource('class C { void set f(value) {} }'))
+        .getType('C')
+        .getSetter('f');
     expect(original, isNotNull);
     PropertyAccessorElement resynthesized = validateGetElement(original);
     comparePropertyAccessorElements(resynthesized, original, 'C.setter f');
   }
 
   test_getElement_unit() {
-    Source source = addSource('class C { f() {} }');
-    CompilationUnitElement original = resolve2(source).definingCompilationUnit;
+    Source source = addTestSource('class C { f() {} }');
+    CompilationUnitElement original =
+        context.computeLibraryElement(source).definingCompilationUnit;
     expect(original, isNotNull);
     CompilationUnitElement resynthesized = validateGetElement(original);
     compareCompilationUnitElements(resynthesized, original);
   }
 
   test_getter_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
@@ skipping 503 matching lines @@
 
   test_metadata_methodDeclaration_method() {
     checkLibrary('const a = null; class C { @a m() {} }');
   }
 
   test_metadata_methodDeclaration_setter() {
     checkLibrary('const a = null; class C { @a set m(value) {} }');
   }
 
   test_metadata_partDirective() {
-    addNamedSource('/foo.dart', 'part of L;');
+    addSource('/foo.dart', 'part of L;');
     checkLibrary('library L; @a part "foo.dart"; const a = null;');
   }
 
   test_metadata_prefixed_variable() {
     addLibrarySource('/a.dart', 'const b = null;');
     checkLibrary('import "a.dart" as a; @a.b class C {}');
   }
 
   test_metadata_simpleFormalParameter() {
     checkLibrary('const a = null; f(@a x) {}');
@@ skipping 54 matching lines @@
 
   test_method_parameter_return_type() {
     checkLibrary('class C { f(int g()) {} }');
   }
 
   test_method_parameter_return_type_void() {
     checkLibrary('class C { f(void g()) {} }');
   }
 
   test_method_type_parameter() {
-    resetWithOptions(createOptions()..enableGenericMethods = true);
+    prepareAnalysisContext(createOptions()..enableGenericMethods = true);
     checkLibrary('class C { T f<T, U>(U u) => null; }');
   }
 
   test_method_type_parameter_in_generic_class() {
-    resetWithOptions(createOptions()..enableGenericMethods = true);
+    prepareAnalysisContext(createOptions()..enableGenericMethods = true);
     checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
   }
 
   test_method_type_parameter_with_function_typed_parameter() {
-    resetWithOptions(createOptions()..enableGenericMethods = true);
+    prepareAnalysisContext(createOptions()..enableGenericMethods = true);
     checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
   }
 
   test_nested_generic_functions_in_generic_class_with_function_typed_params() {
     checkLibrary('''
 class C<T, U> {
   void g<V, W>() {
     void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
     }
   }
@@ skipping 112 matching lines @@
     // Strong mode doesn't do type inference on parameters of top level
     // functions, so it's ok that we don't store inferred type info for them in
     // summaries.
     checkLibrary('''
 void positional([x = 1]) {}
 void named({x: 1}) {}
 ''');
   }
 
   test_parts() {
-    addNamedSource('/a.dart', 'part of my.lib;');
-    addNamedSource('/b.dart', 'part of my.lib;');
+    addSource('/a.dart', 'part of my.lib;');
+    addSource('/b.dart', 'part of my.lib;');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_propagated_type_refers_to_closure() {
     checkLibrary('''
 void f() {
   var x = () => 0;
   var y = x;
 }
 ''');
@@ skipping 115 matching lines @@
 
   test_type_dynamic() {
     checkLibrary('dynamic d;');
   }
 
   test_type_reference_lib_to_lib() {
     checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
   }
 
   test_type_reference_lib_to_part() {
-    addNamedSource(
-        '/a.dart', 'part of l; class C {} enum E { v } typedef F();');
+    addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
     checkLibrary('library l; part "a.dart"; C c; E e; F f;');
   }
 
   test_type_reference_part_to_lib() {
-    addNamedSource('/a.dart', 'part of l; C c; E e; F f;');
+    addSource('/a.dart', 'part of l; C c; E e; F f;');
     checkLibrary(
         'library l; part "a.dart"; class C {} enum E { v } typedef F();');
   }
 
   test_type_reference_part_to_other_part() {
-    addNamedSource(
-        '/a.dart', 'part of l; class C {} enum E { v } typedef F();');
-    addNamedSource('/b.dart', 'part of l; C c; E e; F f;');
+    addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
+    addSource('/b.dart', 'part of l; C c; E e; F f;');
     checkLibrary('library l; part "a.dart"; part "b.dart";');
   }
 
   test_type_reference_part_to_part() {
-    addNamedSource('/a.dart',
+    addSource('/a.dart',
         'part of l; class C {} enum E { v } typedef F(); C c; E e; F f;');
     checkLibrary('library l; part "a.dart";');
   }
 
   test_type_reference_to_class() {
     checkLibrary('class C {} C c;');
   }
 
   test_type_reference_to_class_with_type_arguments() {
     checkLibrary('class C<T, U> {} C<int, String> c;');
@@ skipping 33 matching lines @@
   }
 
   test_type_reference_to_import_export_in_subdirs() {
     addLibrarySource('/a/a.dart', 'export "b/b.dart";');
     addLibrarySource('/a/b/b.dart', 'class C {} enum E { v } typedef F();');
     checkLibrary('import "a/a.dart"; C c; E e; F f;');
   }
 
   test_type_reference_to_import_part() {
     addLibrarySource('/a.dart', 'library l; part "b.dart";');
-    addNamedSource(
-        '/b.dart', 'part of l; class C {} enum E { v } typedef F();');
+    addSource('/b.dart', 'part of l; class C {} enum E { v } typedef F();');
     checkLibrary('import "a.dart"; C c; E e; F f;');
   }
 
   test_type_reference_to_import_part2() {
     addLibrarySource('/a.dart', 'library l; part "p1.dart"; part "p2.dart";');
-    addNamedSource('/p1.dart', 'part of l; class C1 {}');
-    addNamedSource('/p2.dart', 'part of l; class C2 {}');
+    addSource('/p1.dart', 'part of l; class C1 {}');
+    addSource('/p2.dart', 'part of l; class C2 {}');
     checkLibrary('import "a.dart"; C1 c1; C2 c2;');
   }
 
   test_type_reference_to_import_part_in_subdir() {
     addLibrarySource('/a/b.dart', 'library l; part "c.dart";');
-    addNamedSource(
-        '/a/c.dart', 'part of l; class C {} enum E { v } typedef F();');
+    addSource('/a/c.dart', 'part of l; class C {} enum E { v } typedef F();');
     checkLibrary('import "a/b.dart"; C c; E e; F f;');
   }
 
   test_type_reference_to_import_relative() {
     addLibrarySource('/a.dart', 'class C {} enum E { v } typedef F();');
     checkLibrary('import "a.dart"; C c; E e; F f;');
   }
 
   test_type_reference_to_typedef() {
     checkLibrary('typedef F(); F f;');
@@ skipping 95 matching lines @@
  * Docs
  */
 var x;''');
   }
 
   test_variable_final() {
     checkLibrary('final int x = 0;');
   }
 
   test_variable_getterInLib_setterInPart() {
-    addNamedSource('/a.dart', 'part of my.lib; void set x(int _) {}');
+    addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
     checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
   }
 
   test_variable_getterInPart_setterInLib() {
-    addNamedSource('/a.dart', 'part of my.lib; int get x => 42;');
+    addSource('/a.dart', 'part of my.lib; int get x => 42;');
     checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
   }
 
   test_variable_getterInPart_setterInPart() {
-    addNamedSource('/a.dart', 'part of my.lib; int get x => 42;');
-    addNamedSource('/b.dart', 'part of my.lib; void set x(int _) {}');
+    addSource('/a.dart', 'part of my.lib; int get x => 42;');
+    addSource('/b.dart', 'part of my.lib; void set x(int _) {}');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_variable_implicit_type() {
     checkLibrary('var x;');
   }
 
   test_variable_inferred_type_implicit_initialized() {
     checkLibrary('var v = 0;');
   }
 
   test_variable_propagatedType_const_noDep() {
     checkLibrary('const i = 0;');
   }
 
   test_variable_propagatedType_final_dep_inLib() {
     addLibrarySource('/a.dart', 'final a = 1;');
     checkLibrary('import "a.dart"; final b = a / 2;');
   }
 
   test_variable_propagatedType_final_dep_inPart() {
-    addNamedSource('/a.dart', 'part of lib; final a = 1;');
+    addSource('/a.dart', 'part of lib; final a = 1;');
     checkLibrary('library lib; part "a.dart"; final b = a / 2;');
   }
 
   test_variable_propagatedType_final_noDep() {
     checkLibrary('final i = 0;');
   }
 
   test_variable_propagatedType_implicit_dep() {
     // The propagated type is defined in a library that is not imported.
     addLibrarySource('/a.dart', 'class C {}');
     addLibrarySource('/b.dart', 'import "a.dart"; C f() => null;');
     checkLibrary('import "b.dart"; final x = f();');
   }
 
   test_variable_setterInPart_getterInPart() {
-    addNamedSource('/a.dart', 'part of my.lib; void set x(int _) {}');
-    addNamedSource('/b.dart', 'part of my.lib; int get x => 42;');
+    addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
+    addSource('/b.dart', 'part of my.lib; int get x => 42;');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_variables() {
     checkLibrary('int i; int j;');
   }
 
   /**
    * Encode the library containing [original] into a summary and then use
    * [_TestSummaryResynthesizer.getElement] to retrieve just the original
@@ skipping 62 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }