Split summary_test into multiple files.

pkg/analyzer/test/src/summary/summary_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 analyzer.test.src.summary.summary_test;
-
-import 'package:analyzer/analyzer.dart';
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/error.dart';
-import 'package:analyzer/src/generated/java_engine_io.dart';
-import 'package:analyzer/src/generated/parser.dart';
-import 'package:analyzer/src/generated/scanner.dart';
-import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/source_io.dart';
-import 'package:analyzer/src/summary/base.dart';
-import 'package:analyzer/src/summary/format.dart';
-import 'package:analyzer/src/summary/prelink.dart';
-import 'package:analyzer/src/summary/public_namespace_computer.dart'
-    as public_namespace;
-import 'package:analyzer/src/summary/summarize_ast.dart';
-import 'package:analyzer/src/summary/summarize_elements.dart'
-    as summarize_elements;
-import 'package:unittest/unittest.dart';
-
-import '../../generated/resolver_test.dart';
-import '../../reflective_tests.dart';
-
-main() {
-  groupSep = ' | ';
-  runReflectiveTests(SummarizeElementsTest);
-  runReflectiveTests(PrelinkerTest);
-  runReflectiveTests(UnlinkedSummarizeAstTest);
-}
-
-/**
- * The public namespaces of the sdk are computed once so that we don't bog
- * down the test.  Structured as a map from absolute URI to the corresponding
- * public namespace.
- *
- * Note: should an exception occur during computation of this variable, it
- * will silently be set to null to allow other tests to run.
- */
-final Map<String, UnlinkedPublicNamespace> sdkPublicNamespace = () {
-  try {
-    AnalysisContext analysisContext = AnalysisContextFactory.contextWithCore();
-    Map<String, UnlinkedPublicNamespace> uriToNamespace =
-        <String, UnlinkedPublicNamespace>{};
-    List<LibraryElement> libraries = [
-      analysisContext.typeProvider.objectType.element.library,
-      analysisContext.typeProvider.futureType.element.library
-    ];
-    for (LibraryElement library in libraries) {
-      summarize_elements.LibrarySerializationResult serializedLibrary =
-          summarize_elements.serializeLibrary(
-              library, analysisContext.typeProvider);
-      for (int i = 0; i < serializedLibrary.unlinkedUnits.length; i++) {
-        uriToNamespace[serializedLibrary.unitUris[i]] =
-            new UnlinkedUnit.fromBuffer(
-                serializedLibrary.unlinkedUnits[i].toBuffer()).publicNamespace;
-      }
-    }
-    return uriToNamespace;
-  } catch (_) {
-    return null;
-  }
-}();
-
-/**
- * Convert a summary object (or a portion of one) into a canonical form that
- * can be easily compared using [expect].  If [orderByName] is true, and the
- * object is a [List], it is sorted by the `name` field of its elements.
- */
-Object canonicalize(Object obj, {bool orderByName: false}) {
-  if (obj is SummaryClass) {
-    Map<String, Object> result = <String, Object>{};
-    obj.toMap().forEach((String key, Object value) {
-      bool orderByName = false;
-      if (obj is UnlinkedPublicNamespace && key == 'names') {
-        orderByName = true;
-      }
-      result[key] = canonicalize(value, orderByName: orderByName);
-    });
-    return result;
-  } else if (obj is List) {
-    List<Object> result = <Object>[];
-    for (Object item in obj) {
-      result.add(canonicalize(item));
-    }
-    if (orderByName) {
-      result.sort((Object a, Object b) {
-        if (a is Map && b is Map) {
-          return Comparable.compare(a['name'], b['name']);
-        } else {
-          return 0;
-        }
-      });
-    }
-    return result;
-  } else if (obj is String || obj is num || obj is bool) {
-    return obj;
-  } else {
-    return obj.toString();
-  }
-}
-
-UnlinkedPublicNamespace computePublicNamespaceFromText(
-    String text, Source source) {
-  CharacterReader reader = new CharSequenceReader(text);
-  Scanner scanner =
-      new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
-  Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
-  parser.parseGenericMethods = true;
-  CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
-  UnlinkedPublicNamespace namespace = new UnlinkedPublicNamespace.fromBuffer(
-      public_namespace.computePublicNamespace(unit).toBuffer());
-  return namespace;
-}
-
-/**
- * Type of a function that validates an [TypeRef].
- */
-typedef void _TypeRefValidator(TypeRef unlinkedTypeRef);
-
-/**
- * Override of [SummaryTest] which verifies the correctness of the prelinker by
- * creating summaries from the element model, discarding their prelinked
- * information, and then recreating it using the prelinker.
- */
-@reflectiveTest
-class PrelinkerTest extends SummarizeElementsTest {
-  final Map<String, UnlinkedPublicNamespace> uriToPublicNamespace =
-      <String, UnlinkedPublicNamespace>{};
-
-  @override
-  bool get expectAbsoluteUrisInDependencies => false;
-
-  @override
-  bool get skipFullyLinkedData => true;
-
-  @override
-  Source addNamedSource(String filePath, String contents) {
-    Source source = super.addNamedSource(filePath, contents);
-    uriToPublicNamespace[absUri(filePath)] =
-        computePublicNamespaceFromText(contents, source);
-    return source;
-  }
-
-  String resolveToAbsoluteUri(LibraryElement library, String relativeUri) {
-    Source resolvedSource =
-        analysisContext.sourceFactory.resolveUri(library.source, relativeUri);
-    if (resolvedSource == null) {
-      fail('Failed to resolve relative uri "$relativeUri"');
-    }
-    return resolvedSource.uri.toString();
-  }
-
-  @override
-  void serializeLibraryElement(LibraryElement library) {
-    super.serializeLibraryElement(library);
-    Map<String, UnlinkedUnit> uriToUnit = <String, UnlinkedUnit>{};
-    expect(unlinkedUnits.length, unitUris.length);
-    for (int i = 1; i < unlinkedUnits.length; i++) {
-      uriToUnit[unitUris[i]] = unlinkedUnits[i];
-    }
-    UnlinkedUnit getPart(String relativeUri) {
-      String absoluteUri = resolveToAbsoluteUri(library, relativeUri);
-      UnlinkedUnit unit = uriToUnit[absoluteUri];
-      if (unit == null) {
-        fail('Prelinker unexpectedly requested unit for "$relativeUri"'
-            ' (resolves to "$absoluteUri").');
-      }
-      return unit;
-    }
-    UnlinkedPublicNamespace getImport(String relativeUri) {
-      String absoluteUri = resolveToAbsoluteUri(library, relativeUri);
-      UnlinkedPublicNamespace namespace = sdkPublicNamespace[absoluteUri];
-      if (namespace == null) {
-        namespace = uriToPublicNamespace[absoluteUri];
-      }
-      if (namespace == null && !allowMissingFiles) {
-        fail('Prelinker unexpectedly requested namespace for "$relativeUri"'
-            ' (resolves to "$absoluteUri").'
-            '  Namespaces available: ${uriToPublicNamespace.keys}');
-      }
-      return namespace;
-    }
-    linked = new LinkedLibrary.fromBuffer(
-        prelink(unlinkedUnits[0], getPart, getImport).toBuffer());
-  }
-}
-
-/**
- * Override of [SummaryTest] which creates summaries from the element model.
- */
-@reflectiveTest
-class SummarizeElementsTest extends ResolverTestCase with SummaryTest {
-  /**
-   * The list of absolute unit URIs corresponding to the compilation units in
-   * [unlinkedUnits].
-   */
-  List<String> unitUris;
-
-  /**
-   * Map containing all source files in this test, and their corresponding file
-   * contents.
-   */
-  final Map<Source, String> _fileContents = <Source, String>{};
-
-  @override
-  LinkedLibrary linked;
-
-  @override
-  List<UnlinkedUnit> unlinkedUnits;
-
-  @override
-  bool get checkAstDerivedData => false;
-
-  @override
-  bool get expectAbsoluteUrisInDependencies => true;
-
-  @override
-  bool get skipFullyLinkedData => false;
-
-  @override
-  Source addNamedSource(String filePath, String contents) {
-    Source source = super.addNamedSource(filePath, contents);
-    _fileContents[source] = contents;
-    return source;
-  }
-
-  /**
-   * Serialize the library containing the given class [element], then
-   * deserialize it and return the summary of the class.
-   */
-  UnlinkedClass serializeClassElement(ClassElement element) {
-    serializeLibraryElement(element.library);
-    return findClass(element.name, failIfAbsent: true);
-  }
-
-  /**
-   * Serialize the given [library] element, then deserialize it and store the
-   * resulting summary in [linked] and [unlinkedUnits].
-   */
-  void serializeLibraryElement(LibraryElement library) {
-    summarize_elements.LibrarySerializationResult serializedLib =
-        summarize_elements.serializeLibrary(library, typeProvider);
-    {
-      List<int> buffer = serializedLib.linked.toBuffer();
-      linked = new LinkedLibrary.fromBuffer(buffer);
-    }
-    unlinkedUnits = serializedLib.unlinkedUnits.map((UnlinkedUnitBuilder b) {
-      List<int> buffer = b.toBuffer();
-      return new UnlinkedUnit.fromBuffer(buffer);
-    }).toList();
-    unitUris = serializedLib.unitUris;
-  }
-
-  @override
-  void serializeLibraryText(String text, {bool allowErrors: false}) {
-    Source source = addSource(text);
-    _fileContents[source] = text;
-    LibraryElement library = resolve2(source);
-    if (!allowErrors) {
-      assertNoErrors(source);
-    }
-    serializeLibraryElement(library);
-    expect(unlinkedUnits[0].imports.length, linked.importDependencies.length);
-    expect(linked.units.length, unlinkedUnits.length);
-    for (int i = 0; i < linked.units.length; i++) {
-      expect(unlinkedUnits[i].references.length,
-          lessThanOrEqualTo(linked.units[i].references.length));
-    }
-    verifyPublicNamespace();
-  }
-
-  @override
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    options.enableGenericMethods = true;
-    resetWithOptions(options);
-  }
-
-  test_class_no_superclass() {
-    UnlinkedClass cls = serializeClassElement(typeProvider.objectType.element);
-    expect(cls.supertype, isNull);
-    expect(cls.hasNoSupertype, isTrue);
-  }
-
-  /**
-   * Verify that [public_namespace.computePublicNamespace] produces data that's
-   * equivalent to that produced by [summarize_elements.serializeLibrary].
-   */
-  void verifyPublicNamespace() {
-    for (int i = 0; i < unlinkedUnits.length; i++) {
-      Source source = analysisContext.sourceFactory.forUri(unitUris[i]);
-      String text = _fileContents[source];
-      if (text == null) {
-        if (!allowMissingFiles) {
-          fail('Could not find file while verifying public namespace: '
-              '${unitUris[i]}');
-        }
-      } else {
-        UnlinkedPublicNamespace namespace =
-            computePublicNamespaceFromText(text, source);
-        expect(canonicalize(namespace),
-            canonicalize(unlinkedUnits[i].publicNamespace),
-            reason: 'publicNamespace(${unitUris[i]})');
-      }
-    }
-  }
-}
-
-/**
- * Base class containing most summary tests.  This allows summary tests to be
- * re-used to exercise all the different ways in which summaries can be
- * generated (e.g. direct from the AST, from the element model, from a
- * "relinking" process, etc.)
- */
-abstract class SummaryTest {
-  /**
-   * A test will set this to `true` if it contains `import`, `export`, or
-   * `part` declarations that deliberately refer to non-existent files.
-   */
-  bool allowMissingFiles = false;
-
-  /**
-   * `true` if the summary was created directly from the AST (and hence
-   * contains information that is not obtainable from the element model alone).
-   * TODO(paulberry): modify the element model so that it contains all the data
-   * that summaries need, so that this flag is no longer needed.
-   */
-  bool get checkAstDerivedData;
-
-  /**
-   * Get access to the linked defining compilation unit.
-   */
-  LinkedUnit get definingUnit => linked.units[0];
-
-  /**
-   * `true` if the linked portion of the summary is expected to contain
-   * absolute URIs.  This happens because the element model doesn't (yet) store
-   * enough information to recover relative URIs, TODO(paulberry): fix this.
-   */
-  bool get expectAbsoluteUrisInDependencies;
-
-  /**
-   * Get access to the linked summary that results from serializing and
-   * then deserializing the library under test.
-   */
-  LinkedLibrary get linked;
-
-  /**
-   * `true` if the linked portion of the summary only contains prelinked data.
-   * This happens because we don't yet have a full linker; only a prelinker.
-   */
-  bool get skipFullyLinkedData;
-
-  /**
-   * Get access to the unlinked compilation unit summaries that result from
-   * serializing and deserializing the library under test.
-   */
-  List<UnlinkedUnit> get unlinkedUnits;
-
-  /**
-   * Convert [path] to a suitably formatted absolute path URI for the current
-   * platform.
-   */
-  String absUri(String path) {
-    return FileUtilities2.createFile(path).toURI().toString();
-  }
-
-  /**
-   * Add the given source file so that it may be referenced by the file under
-   * test.
-   */
-  Source addNamedSource(String filePath, String contents);
-
-  /**
-   * Verify that the [dependency]th element of the dependency table represents
-   * a file reachable via the given [absoluteUri] and [relativeUri].
-   */
-  void checkDependency(int dependency, String absoluteUri, String relativeUri) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUri = absoluteUri;
-    }
-    expect(dependency, new isInstanceOf<int>());
-    expect(linked.dependencies[dependency].uri, relativeUri);
-  }
-
-  /**
-   * Verify that the given [dependency] lists the given [absoluteUris] or
-   * [relativeUris] as its parts.
-   */
-  void checkDependencyParts(LinkedDependency dependency,
-      List<String> absoluteUris, List<String> relativeUris) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUris = absoluteUris;
-    }
-    expect(dependency.parts, relativeUris);
-  }
-
-  /**
-   * Check that the given [documentationComment] matches the first
-   * Javadoc-style comment found in [text].
-   *
-   * Note that the algorithm for finding the Javadoc-style comment in [text] is
-   * a simple-minded text search; it is easily confused by corner cases such as
-   * strings containing comments, nested comments, etc.
-   */
-  void checkDocumentationComment(
-      UnlinkedDocumentationComment documentationComment, String text) {
-    expect(documentationComment, isNotNull);
-    int commentStart = text.indexOf('/*');
-    expect(commentStart, isNot(-1));
-    int commentEnd = text.indexOf('*/');
-    expect(commentEnd, isNot(-1));
-    commentEnd += 2;
-    String expectedCommentText =
-        text.substring(commentStart, commentEnd).replaceAll('\r\n', '\n');
-    expect(documentationComment.text, expectedCommentText);
-    expect(documentationComment.offset, commentStart);
-    expect(documentationComment.length, commentEnd - commentStart);
-  }
-
-  /**
-   * Verify that the given [typeRef] represents the type `dynamic`.
-   */
-  void checkDynamicTypeRef(TypeRef typeRef) {
-    checkTypeRef(typeRef, null, null, null);
-  }
-
-  /**
-   * Verify that the given [exportName] represents a reference to an entity
-   * declared in a file reachable via [absoluteUri] and [relativeUri], having
-   * name [expectedName].  [expectedKind] is the kind of object referenced.
-   * [expectedTargetUnit] is the index of the compilation unit in which the
-   * target of the [exportName] is expected to appear; if not specified it is
-   * assumed to be the defining compilation unit.
-   */
-  void checkExportName(LinkedExportName exportName, String absoluteUri,
-      String relativeUri, String expectedName, ReferenceKind expectedKind,
-      {int expectedTargetUnit: 0}) {
-    expect(exportName, new isInstanceOf<LinkedExportName>());
-    // Exported names must come from other libraries.
-    expect(exportName.dependency, isNot(0));
-    checkDependency(exportName.dependency, absoluteUri, relativeUri);
-    expect(exportName.name, expectedName);
-    expect(exportName.kind, expectedKind);
-    expect(exportName.unit, expectedTargetUnit);
-  }
-
-  /**
-   * Verify that the dependency table contains an entry for a file reachable
-   * via the given [absoluteUri] and [relativeUri].  If [fullyLinked] is
-   * `true`, then the dependency should be a fully-linked dependency; otherwise
-   * it should be a prelinked dependency.
-   *
-   * The index of the [LinkedDependency] is returned.
-   */
-  int checkHasDependency(String absoluteUri, String relativeUri,
-      {bool fullyLinked: false}) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUri = absoluteUri;
-    }
-    List<String> found = <String>[];
-    for (int i = 0; i < linked.dependencies.length; i++) {
-      LinkedDependency dep = linked.dependencies[i];
-      if (dep.uri == relativeUri) {
-        if (fullyLinked) {
-          expect(i, greaterThanOrEqualTo(linked.numPrelinkedDependencies));
-        } else {
-          expect(i, lessThan(linked.numPrelinkedDependencies));
-        }
-        return i;
-      }
-      found.add(dep.uri);
-    }
-    fail('Did not find dependency $relativeUri.  Found: $found');
-    return null;
-  }
-
-  /**
-   * Verify that the dependency table *does not* contain any entries for a file
-   * reachable via the given [absoluteUri] and [relativeUri].
-   */
-  void checkLacksDependency(String absoluteUri, String relativeUri) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUri = absoluteUri;
-    }
-    for (LinkedDependency dep in linked.dependencies) {
-      if (dep.uri == relativeUri) {
-        fail('Unexpected dependency found: $relativeUri');
-      }
-    }
-  }
-
-  /**
-   * Verify that the given [typeRef] represents a reference to a type declared
-   * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [allowTypeParameters] is true, allow the type
-   * reference to supply type parameters.  [expectedKind] is the kind of object
-   * referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer to the
-   * compilation unit within which the [typeRef] appears; if not specified they
-   * are assumed to refer to the defining compilation unit.
-   * [expectedTargetUnit] is the index of the compilation unit in which the
-   * target of the [typeRef] is expected to appear; if not specified it is
-   * assumed to be the defining compilation unit.  [numTypeParameters] is the
-   * number of type parameters of the thing being referred to.
-   */
-  void checkLinkedTypeRef(TypeRef typeRef, String absoluteUri,
-      String relativeUri, String expectedName,
-      {bool allowTypeParameters: false,
-      ReferenceKind expectedKind: ReferenceKind.classOrEnum,
-      int expectedTargetUnit: 0,
-      LinkedUnit linkedSourceUnit,
-      UnlinkedUnit unlinkedSourceUnit,
-      int numTypeParameters: 0}) {
-    linkedSourceUnit ??= definingUnit;
-    expect(typeRef, isNotNull,
-        reason: 'No entry in linkedSourceUnit.types matching slotId');
-    expect(typeRef.paramReference, 0);
-    int index = typeRef.reference;
-    if (!allowTypeParameters) {
-      expect(typeRef.typeArguments, isEmpty);
-    }
-    checkTypeRefCommonElements(
-        index,
-        absoluteUri,
-        relativeUri,
-        expectedName,
-        expectedKind,
-        expectedTargetUnit,
-        linkedSourceUnit,
-        unlinkedSourceUnit,
-        numTypeParameters);
-  }
-
-  /**
-   * Verify that the given [slotId] represents a reference to a type declared
-   * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [allowTypeParameters] is true, allow the type
-   * reference to supply type parameters.  [expectedKind] is the kind of object
-   * referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer to the
-   * compilation unit within which the [typeRef] appears; if not specified they
-   * are assumed to refer to the defining compilation unit.
-   * [expectedTargetUnit] is the index of the compilation unit in which the
-   * target of the [typeRef] is expected to appear; if not specified it is
-   * assumed to be the defining compilation unit.  [numTypeParameters] is the
-   * number of type parameters of the thing being referred to.
-   */
-  void checkLinkedTypeSlot(
-      int slotId, String absoluteUri, String relativeUri, String expectedName,
-      {bool allowTypeParameters: false,
-      ReferenceKind expectedKind: ReferenceKind.classOrEnum,
-      int expectedTargetUnit: 0,
-      LinkedUnit linkedSourceUnit,
-      UnlinkedUnit unlinkedSourceUnit,
-      int numTypeParameters: 0}) {
-    // Slot ids should be nonzero, since zero means "no associated slot".
-    expect(slotId, isNot(0));
-    if (skipFullyLinkedData) {
-      return;
-    }
-    linkedSourceUnit ??= definingUnit;
-    checkLinkedTypeRef(
-        getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
-        absoluteUri,
-        relativeUri,
-        expectedName,
-        allowTypeParameters: allowTypeParameters,
-        expectedKind: expectedKind,
-        expectedTargetUnit: expectedTargetUnit,
-        linkedSourceUnit: linkedSourceUnit,
-        unlinkedSourceUnit: unlinkedSourceUnit,
-        numTypeParameters: numTypeParameters);
-  }
-
-  /**
-   * Verify that the given [typeRef] represents a reference to a type parameter
-   * having the given [deBruijnIndex].
-   */
-  void checkParamTypeRef(TypeRef typeRef, int deBruijnIndex) {
-    expect(typeRef, new isInstanceOf<TypeRef>());
-    expect(typeRef.reference, 0);
-    expect(typeRef.typeArguments, isEmpty);
-    expect(typeRef.paramReference, deBruijnIndex);
-  }
-
-  /**
-   * Verify that [prefixReference] is a valid reference to a prefix having the
-   * given [name].
-   */
-  void checkPrefix(int prefixReference, String name) {
-    expect(prefixReference, isNot(0));
-    expect(unlinkedUnits[0].references[prefixReference].prefixReference, 0);
-    expect(unlinkedUnits[0].references[prefixReference].name, name);
-    expect(definingUnit.references[prefixReference].dependency, 0);
-    expect(definingUnit.references[prefixReference].kind, ReferenceKind.prefix);
-    expect(definingUnit.references[prefixReference].unit, 0);
-  }
-
-  /**
-   * Verify that the given [typeRef] represents a reference to a type declared
-   * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [expectedPrefix] is supplied, verify that the type is
-   * reached via the given prefix.  If [allowTypeParameters] is true, allow the
-   * type reference to supply type parameters.  [expectedKind] is the kind of
-   * object referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer
-   * to the compilation unit within which the [typeRef] appears; if not
-   * specified they are assumed to refer to the defining compilation unit.
-   * [expectedTargetUnit] is the index of the compilation unit in which the
-   * target of the [typeRef] is expected to appear; if not specified it is
-   * assumed to be the defining compilation unit.  [numTypeParameters] is the
-   * number of type parameters of the thing being referred to.
-   */
-  void checkTypeRef(TypeRef typeRef, String absoluteUri, String relativeUri,
-      String expectedName,
-      {String expectedPrefix,
-      bool allowTypeParameters: false,
-      ReferenceKind expectedKind: ReferenceKind.classOrEnum,
-      int expectedTargetUnit: 0,
-      LinkedUnit linkedSourceUnit,
-      UnlinkedUnit unlinkedSourceUnit,
-      int numTypeParameters: 0}) {
-    linkedSourceUnit ??= definingUnit;
-    expect(typeRef, new isInstanceOf<TypeRef>());
-    expect(typeRef.paramReference, 0);
-    int index = typeRef.reference;
-    if (!allowTypeParameters) {
-      expect(typeRef.typeArguments, isEmpty);
-    }
-    UnlinkedReference reference = checkTypeRefCommonElements(
-        index,
-        absoluteUri,
-        relativeUri,
-        expectedName,
-        expectedKind,
-        expectedTargetUnit,
-        linkedSourceUnit,
-        unlinkedSourceUnit,
-        numTypeParameters);
-    expect(reference, isNotNull,
-        reason: 'Unlinked type refs must refer to an explicit reference');
-    if (expectedKind == ReferenceKind.unresolved && !checkAstDerivedData) {
-      // summarize_elements.dart isn't yet able to record the prefix of
-      // unresolved references.  TODO(paulberry): fix this.
-      expect(reference.prefixReference, 0);
-    } else if (expectedPrefix == null) {
-      expect(reference.prefixReference, 0);
-    } else {
-      checkPrefix(reference.prefixReference, expectedPrefix);
-    }
-  }
-
-  /**
-   * Check the data structures that are common between [checkTypeRef] and
-   * [checkLinkedTypeRef].  If the type reference in question is an explicit
-   * reference, return the [UnlinkedReference] that is used to make the
-   * explicit reference.  If the type reference in question is an implicit
-   * reference, return `null`.
-   */
-  UnlinkedReference checkTypeRefCommonElements(
-      int referenceIndex,
-      String absoluteUri,
-      String relativeUri,
-      String expectedName,
-      ReferenceKind expectedKind,
-      int expectedTargetUnit,
-      LinkedUnit linkedSourceUnit,
-      UnlinkedUnit unlinkedSourceUnit,
-      int numTypeParameters) {
-    unlinkedSourceUnit ??= unlinkedUnits[0];
-    LinkedReference referenceResolution =
-        linkedSourceUnit.references[referenceIndex];
-    String name;
-    UnlinkedReference reference;
-    if (referenceIndex < unlinkedSourceUnit.references.length) {
-      // This is an explicit reference, so its name and prefix should be in
-      // [UnlinkedUnit.references].
-      expect(referenceResolution.name, isEmpty);
-      reference = unlinkedSourceUnit.references[referenceIndex];
-      name = reference.name;
-      if (reference.prefixReference != 0) {
-        // Prefixes should appear in the references table before any reference
-        // that uses them.
-        expect(reference.prefixReference, lessThan(referenceIndex));
-      }
-    } else {
-      // This is an implicit reference, so its name should be in
-      // [LinkedUnit.references].
-      name = referenceResolution.name;
-    }
-    if (referenceIndex == 0) {
-      // Index 0 is reserved for "dynamic".
-      expect(name, isEmpty);
-    }
-    if (absoluteUri == null) {
-      expect(referenceResolution.dependency, 0);
-    } else {
-      checkDependency(referenceResolution.dependency, absoluteUri, relativeUri);
-    }
-    if (expectedKind == ReferenceKind.unresolved && !checkAstDerivedData) {
-      // summarize_elements.dart isn't yet able to record the name of
-      // unresolved references.  TODO(paulberry): fix this.
-      expect(name, '*unresolved*');
-    } else {
-      if (expectedName == null) {
-        expect(name, isEmpty);
-      } else {
-        expect(name, expectedName);
-      }
-    }
-    expect(referenceResolution.kind, expectedKind);
-    expect(referenceResolution.unit, expectedTargetUnit);
-    expect(referenceResolution.numTypeParameters, numTypeParameters);
-    return reference;
-  }
-
-  /**
-   * Verify that the given [typeRef] represents a reference to an unresolved
-   * type.
-   */
-  void checkUnresolvedTypeRef(
-      TypeRef typeRef, String expectedPrefix, String expectedName,
-      {LinkedUnit linkedSourceUnit, UnlinkedUnit unlinkedSourceUnit}) {
-    // When serializing from the element model, unresolved type refs lose their
-    // name.
-    checkTypeRef(typeRef, null, null, checkAstDerivedData ? expectedName : null,
-        expectedPrefix: expectedPrefix,
-        expectedKind: ReferenceKind.unresolved,
-        linkedSourceUnit: linkedSourceUnit,
-        unlinkedSourceUnit: unlinkedSourceUnit);
-  }
-
-  fail_constExpr_pushInt_shiftOr() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = 0x111222333444555666;');
-    //                                     ^^!!!!^^^^!!!!^^^^
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.shiftOr,
-      UnlinkedConstOperation.shiftOr
-    ], ints: [
-      0x11,
-      0x12223334,
-      0x44555666
-    ]);
-  }
-
-  fail_enum_value_documented() {
-    // TODO(paulberry): currently broken because of dartbug.com/25385
-    String text = '''
-enum E {
-  /**
-   * Docs
-   */
-  v
-}''';
-    UnlinkedEnumValue value = serializeEnumText(text).values[0];
-    expect(value.documentationComment, isNotNull);
-    checkDocumentationComment(value.documentationComment, text);
-  }
-
-  /**
-   * Find the class with the given [className] in the summary, and return its
-   * [UnlinkedClass] data structure.  If [unit] is not given, the class is
-   * looked for in the defining compilation unit.
-   */
-  UnlinkedClass findClass(String className,
-      {bool failIfAbsent: false, UnlinkedUnit unit}) {
-    unit ??= unlinkedUnits[0];
-    UnlinkedClass result;
-    for (UnlinkedClass cls in unit.classes) {
-      if (cls.name == className) {
-        if (result != null) {
-          fail('Duplicate class $className');
-        }
-        result = cls;
-      }
-    }
-    if (result == null && failIfAbsent) {
-      fail('Class $className not found in serialized output');
-    }
-    return result;
-  }
-
-  /**
-   * Find the enum with the given [enumName] in the summary, and return its
-   * [UnlinkedEnum] data structure.  If [unit] is not given, the enum is looked
-   * for in the defining compilation unit.
-   */
-  UnlinkedEnum findEnum(String enumName,
-      {bool failIfAbsent: false, UnlinkedUnit unit}) {
-    unit ??= unlinkedUnits[0];
-    UnlinkedEnum result;
-    for (UnlinkedEnum e in unit.enums) {
-      if (e.name == enumName) {
-        if (result != null) {
-          fail('Duplicate enum $enumName');
-        }
-        result = e;
-      }
-    }
-    if (result == null && failIfAbsent) {
-      fail('Enum $enumName not found in serialized output');
-    }
-    return result;
-  }
-
-  /**
-   * Find the executable with the given [executableName] in the summary, and
-   * return its [UnlinkedExecutable] data structure.  If [executables] is not
-   * given, then the executable is searched for in the defining compilation
-   * unit.
-   */
-  UnlinkedExecutable findExecutable(String executableName,
-      {List<UnlinkedExecutable> executables, bool failIfAbsent: false}) {
-    executables ??= unlinkedUnits[0].executables;
-    UnlinkedExecutable result;
-    for (UnlinkedExecutable executable in executables) {
-      if (executable.name == executableName) {
-        if (result != null) {
-          fail('Duplicate executable $executableName');
-        }
-        result = executable;
-      }
-    }
-    if (result == null && failIfAbsent) {
-      fail('Executable $executableName not found in serialized output');
-    }
-    return result;
-  }
-
-  /**
-   * Find the typedef with the given [typedefName] in the summary, and return
-   * its [UnlinkedTypedef] data structure.  If [unit] is not given, the typedef
-   * is looked for in the defining compilation unit.
-   */
-  UnlinkedTypedef findTypedef(String typedefName,
-      {bool failIfAbsent: false, UnlinkedUnit unit}) {
-    unit ??= unlinkedUnits[0];
-    UnlinkedTypedef result;
-    for (UnlinkedTypedef type in unit.typedefs) {
-      if (type.name == typedefName) {
-        if (result != null) {
-          fail('Duplicate typedef $typedefName');
-        }
-        result = type;
-      }
-    }
-    if (result == null && failIfAbsent) {
-      fail('Typedef $typedefName not found in serialized output');
-    }
-    return result;
-  }
-
-  /**
-   * Find the top level variable with the given [variableName] in the summary,
-   * and return its [UnlinkedVariable] data structure.  If [variables] is not
-   * specified, the variable is looked for in the defining compilation unit.
-   */
-  UnlinkedVariable findVariable(String variableName,
-      {List<UnlinkedVariable> variables, bool failIfAbsent: false}) {
-    variables ??= unlinkedUnits[0].variables;
-    UnlinkedVariable result;
-    for (UnlinkedVariable variable in variables) {
-      if (variable.name == variableName) {
-        if (result != null) {
-          fail('Duplicate variable $variableName');
-        }
-        result = variable;
-      }
-    }
-    if (result == null && failIfAbsent) {
-      fail('Variable $variableName not found in serialized output');
-    }
-    return result;
-  }
-
-  /**
-   * Find the entry in [linkedSourceUnit.types] matching [slotId].
-   */
-  TypeRef getTypeRefForSlot(int slotId, {LinkedUnit linkedSourceUnit}) {
-    linkedSourceUnit ??= definingUnit;
-    for (TypeRef typeRef in linkedSourceUnit.types) {
-      if (typeRef.slot == slotId) {
-        return typeRef;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Serialize the given library [text] and return the summary of the class
-   * with the given [className].
-   */
-  UnlinkedClass serializeClassText(String text,
-      {String className: 'C', bool allowErrors: false}) {
-    serializeLibraryText(text, allowErrors: allowErrors);
-    return findClass(className, failIfAbsent: true);
-  }
-
-  /**
-   * Serialize the given library [text] and return the summary of the enum with
-   * the given [enumName].
-   */
-  UnlinkedEnum serializeEnumText(String text, [String enumName = 'E']) {
-    serializeLibraryText(text);
-    return findEnum(enumName, failIfAbsent: true);
-  }
-
-  /**
-   * Serialize the given library [text] and return the summary of the
-   * executable with the given [executableName].
-   */
-  UnlinkedExecutable serializeExecutableText(String text,
-      [String executableName = 'f']) {
-    serializeLibraryText(text);
-    return findExecutable(executableName, failIfAbsent: true);
-  }
-
-  /**
-   * Serialize the given library [text], then deserialize it and store its
-   * summary in [lib].
-   */
-  void serializeLibraryText(String text, {bool allowErrors: false});
-
-  /**
-   * Serialize the given method [text] and return the summary of the executable
-   * with the given [executableName].
-   */
-  UnlinkedExecutable serializeMethodText(String text,
-      [String executableName = 'f']) {
-    serializeLibraryText('class C { $text }');
-    return findExecutable(executableName,
-        executables: findClass('C', failIfAbsent: true).executables,
-        failIfAbsent: true);
-  }
-
-  /**
-   * Serialize the given library [text] and return the summary of the typedef
-   * with the given [typedefName].
-   */
-  UnlinkedTypedef serializeTypedefText(String text,
-      [String typedefName = 'F']) {
-    serializeLibraryText(text);
-    return findTypedef(typedefName, failIfAbsent: true);
-  }
-
-  /**
-   * Serialize a type declaration using the given [text] as a type name, and
-   * return a summary of the corresponding [TypeRef].  If the type
-   * declaration needs to refer to types that are not available in core, those
-   * types may be declared in [otherDeclarations].
-   */
-  TypeRef serializeTypeText(String text,
-      {String otherDeclarations: '', bool allowErrors: false}) {
-    return serializeVariableText('$otherDeclarations\n$text v;',
-        allowErrors: allowErrors).type;
-  }
-
-  /**
-   * Serialize the given library [text] and return the summary of the variable
-   * with the given [variableName].
-   */
-  UnlinkedVariable serializeVariableText(String text,
-      {String variableName: 'v', bool allowErrors: false}) {
-    serializeLibraryText(text, allowErrors: allowErrors);
-    return findVariable(variableName, failIfAbsent: true);
-  }
-
-  test_cascaded_export_hide_hide() {
-    addNamedSource('/lib1.dart', 'export "lib2.dart" hide C hide B, C;');
-    addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib1.dart';
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_export_hide_show() {
-    addNamedSource('/lib1.dart', 'export "lib2.dart" hide C show A, C;');
-    addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib1.dart';
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_export_show_hide() {
-    addNamedSource('/lib1.dart', 'export "lib2.dart" show A, B hide B, C;');
-    addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib1.dart';
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_export_show_show() {
-    addNamedSource('/lib1.dart', 'export "lib2.dart" show A, B show A, C;');
-    addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib1.dart';
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_import_hide_hide() {
-    addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib.dart' hide C hide B, C;
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_import_hide_show() {
-    addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib.dart' hide C show A, C;
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_import_show_hide() {
-    addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib.dart' show A, B hide B, C;
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_cascaded_import_show_show() {
-    addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
-    serializeLibraryText(
-        '''
-import 'lib.dart' show A, B show A, C;
-A a;
-B b;
-C c;
-    ''',
-        allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
-    checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
-    checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
-  }
-
-  test_class_abstract() {
-    UnlinkedClass cls = serializeClassText('abstract class C {}');
-    expect(cls.isAbstract, true);
-  }
-
-  test_class_alias_abstract() {
-    UnlinkedClass cls = serializeClassText(
-        'abstract class C = D with E; class D {} class E {}');
-    expect(cls.isAbstract, true);
-  }
-
-  test_class_alias_concrete() {
-    UnlinkedClass cls =
-        serializeClassText('class C = _D with _E; class _D {} class _E {}');
-    expect(cls.isAbstract, false);
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.classOrEnum);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
-  }
-
-  test_class_alias_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-class C = D with E;
-
-class D {}
-class E {}''';
-    UnlinkedClass cls = serializeClassText(text);
-    expect(cls.documentationComment, isNotNull);
-    checkDocumentationComment(cls.documentationComment, text);
-  }
-
-  test_class_alias_flag() {
-    UnlinkedClass cls =
-        serializeClassText('class C = D with E; class D {} class E {}');
-    expect(cls.isMixinApplication, true);
-  }
-
-  test_class_alias_generic() {
-    serializeClassText('class C<A, B> = _D with _E; class _D {} class _E {}');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 2);
-  }
-
-  test_class_alias_mixin_order() {
-    UnlinkedClass cls = serializeClassText('''
-class C = D with E, F;
-class D {}
-class E {}
-class F {}
-''');
-    expect(cls.mixins, hasLength(2));
-    checkTypeRef(cls.mixins[0], null, null, 'E');
-    checkTypeRef(cls.mixins[1], null, null, 'F');
-  }
-
-  test_class_alias_no_implicit_constructors() {
-    UnlinkedClass cls = serializeClassText('''
-class C = D with E;
-class D {
-  D.foo();
-  D.bar();
-}
-class E {}
-''');
-    expect(cls.executables, isEmpty);
-  }
-
-  test_class_alias_private() {
-    serializeClassText('class _C = _D with _E; class _D {} class _E {}',
-        className: '_C');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_class_alias_reference_generic() {
-    TypeRef typeRef = serializeTypeText('C',
-        otherDeclarations: 'class C<D, E> = F with G; class F {} class G {}');
-    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
-  }
-
-  test_class_alias_reference_generic_imported() {
-    addNamedSource(
-        '/lib.dart', 'class C<D, E> = F with G; class F {} class G {}');
-    TypeRef typeRef =
-        serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
-    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
-        numTypeParameters: 2);
-  }
-
-  test_class_alias_supertype() {
-    UnlinkedClass cls =
-        serializeClassText('class C = D with E; class D {} class E {}');
-    checkTypeRef(cls.supertype, null, null, 'D');
-    expect(cls.hasNoSupertype, isFalse);
-  }
-
-  test_class_concrete() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.isAbstract, false);
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.classOrEnum);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
-  }
-
-  test_class_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-class C {}''';
-    UnlinkedClass cls = serializeClassText(text);
-    expect(cls.documentationComment, isNotNull);
-    checkDocumentationComment(cls.documentationComment, text);
-  }
-
-  test_class_documented_with_references() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs referring to [D] and [E]
- */
-class C {}
-
-class D {}
-class E {}''';
-    UnlinkedClass cls = serializeClassText(text);
-    expect(cls.documentationComment, isNotNull);
-    checkDocumentationComment(cls.documentationComment, text);
-  }
-
-  test_class_documented_with_with_windows_line_endings() {
-    String text = '/**\r\n * Docs\r\n */\r\nclass C {}';
-    UnlinkedClass cls = serializeClassText(text);
-    expect(cls.documentationComment, isNotNull);
-    checkDocumentationComment(cls.documentationComment, text);
-  }
-
-  test_class_interface() {
-    UnlinkedClass cls = serializeClassText('''
-class C implements D {}
-class D {}
-''');
-    expect(cls.interfaces, hasLength(1));
-    checkTypeRef(cls.interfaces[0], null, null, 'D');
-  }
-
-  test_class_interface_order() {
-    UnlinkedClass cls = serializeClassText('''
-class C implements D, E {}
-class D {}
-class E {}
-''');
-    expect(cls.interfaces, hasLength(2));
-    checkTypeRef(cls.interfaces[0], null, null, 'D');
-    checkTypeRef(cls.interfaces[1], null, null, 'E');
-  }
-
-  test_class_mixin() {
-    UnlinkedClass cls = serializeClassText('''
-class C extends Object with D {}
-class D {}
-''');
-    expect(cls.mixins, hasLength(1));
-    checkTypeRef(cls.mixins[0], null, null, 'D');
-  }
-
-  test_class_mixin_order() {
-    UnlinkedClass cls = serializeClassText('''
-class C extends Object with D, E {}
-class D {}
-class E {}
-''');
-    expect(cls.mixins, hasLength(2));
-    checkTypeRef(cls.mixins[0], null, null, 'D');
-    checkTypeRef(cls.mixins[1], null, null, 'E');
-  }
-
-  test_class_name() {
-    var classText = 'class C {}';
-    UnlinkedClass cls = serializeClassText(classText);
-    expect(cls.name, 'C');
-    expect(cls.nameOffset, classText.indexOf('C'));
-  }
-
-  test_class_no_flags() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.isAbstract, false);
-    expect(cls.isMixinApplication, false);
-  }
-
-  test_class_no_interface() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.interfaces, isEmpty);
-  }
-
-  test_class_no_mixins() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.mixins, isEmpty);
-  }
-
-  test_class_no_type_param() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.typeParameters, isEmpty);
-  }
-
-  test_class_non_alias_flag() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.isMixinApplication, false);
-  }
-
-  test_class_private() {
-    serializeClassText('class _C {}', className: '_C');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_class_reference_generic() {
-    TypeRef typeRef =
-        serializeTypeText('C', otherDeclarations: 'class C<D, E> {}');
-    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
-  }
-
-  test_class_reference_generic_imported() {
-    addNamedSource('/lib.dart', 'class C<D, E> {}');
-    TypeRef typeRef =
-        serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
-    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
-        numTypeParameters: 2);
-  }
-
-  test_class_superclass() {
-    UnlinkedClass cls = serializeClassText('class C {}');
-    expect(cls.supertype, isNull);
-    expect(cls.hasNoSupertype, isFalse);
-  }
-
-  test_class_superclass_explicit() {
-    UnlinkedClass cls = serializeClassText('class C extends D {} class D {}');
-    expect(cls.supertype, isNotNull);
-    checkTypeRef(cls.supertype, null, null, 'D');
-    expect(cls.hasNoSupertype, isFalse);
-  }
-
-  test_class_type_param_bound() {
-    UnlinkedClass cls = serializeClassText('class C<T extends List> {}');
-    expect(cls.typeParameters, hasLength(1));
-    expect(cls.typeParameters[0].name, 'T');
-    expect(cls.typeParameters[0].bound, isNotNull);
-    checkTypeRef(cls.typeParameters[0].bound, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
-  }
-
-  test_class_type_param_f_bound() {
-    UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
-    TypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
-    checkParamTypeRef(typeArgument, 2);
-  }
-
-  test_class_type_param_f_bound_self_ref() {
-    UnlinkedClass cls = serializeClassText('class C<T, U extends List<U>> {}');
-    TypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
-    checkParamTypeRef(typeArgument, 1);
-  }
-
-  test_class_type_param_no_bound() {
-    String text = 'class C<T> {}';
-    UnlinkedClass cls = serializeClassText(text);
-    expect(cls.typeParameters, hasLength(1));
-    expect(cls.typeParameters[0].name, 'T');
-    expect(cls.typeParameters[0].nameOffset, text.indexOf('T'));
-    expect(cls.typeParameters[0].bound, isNull);
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
-  }
-
-  test_constExpr_binary_add() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 + 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_and() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = true && false;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.pushFalse,
-      UnlinkedConstOperation.and
-    ]);
-  }
-
-  test_constExpr_binary_bitAnd() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 & 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitAnd
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_bitOr() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 | 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitOr
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_bitShiftLeft() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 << 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitShiftLeft
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_bitShiftRight() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 >> 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitShiftRight
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_bitXor() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 ^ 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.bitXor
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_divide() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 / 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.divide
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_equal() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 == 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.equal
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_equal_not() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 != 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.equal,
-      UnlinkedConstOperation.not
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_floorDivide() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 ~/ 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.floorDivide
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_greater() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 > 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.greater
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_greaterEqual() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 >= 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.greaterEqual
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_less() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 < 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.less
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_lessEqual() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 <= 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.lessEqual
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_modulo() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 % 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.modulo
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_multiply() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 * 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.multiply
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_binary_or() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = false || true;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushFalse,
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.or
-    ]);
-  }
-
-  test_constExpr_binary_subtract() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1 - 2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.subtract
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_conditional() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = true ? 1 : 2;', allowErrors: true);
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.conditional
-    ], ints: [
-      1,
-      2
-    ]);
-  }
-
-  test_constExpr_identical() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = identical(42, null);');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushNull,
-      UnlinkedConstOperation.identical
-    ], ints: [
-      42
-    ]);
-  }
-
-  test_constExpr_invokeConstructor_named() {
-    if (checkAstDerivedData) {
-      // TODO(scheglov) at the moment we cannot link class member references
-      return;
-    }
-    UnlinkedVariable variable = serializeVariableText('''
-class C {
-  const C.named();
-}
-const v = const C.named();
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
-    ], ints: [
-      0
-    ], strings: [
-      'named'
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_invokeConstructor_named_imported() {
-    if (checkAstDerivedData) {
-      // TODO(scheglov) at the moment we cannot link class member references
-      return;
-    }
-    addNamedSource(
-        '/a.dart',
-        '''
-class C {
-  const C.named();
-}
-''');
-    UnlinkedVariable variable = serializeVariableText('''
-import 'a.dart';
-const v = const C.named();
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
-    ], ints: [
-      0
-    ], strings: [
-      'named'
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_invokeConstructor_named_imported_withPrefix() {
-    addNamedSource(
-        '/a.dart',
-        '''
-class C {
-  const C.named();
-}
-''');
-    UnlinkedVariable variable = serializeVariableText('''
-import 'a.dart' as p;
-const v = const p.C.named();
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.invokeConstructor,
-    ], ints: [
-      0
-    ], strings: [
-      'named'
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
-          expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'p')
-    ]);
-  }
-
-  test_constExpr_invokeConstructor_unnamed() {
-    UnlinkedVariable variable = serializeVariableText('''
-class C {
-  const C(int a, String b);
-}
-const v = const C(42, 'sss');
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.invokeConstructor,
-    ], ints: [
-      42,
-      2
-    ], strings: [
-      'sss',
-      ''
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_length() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = "abc".length;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators:
-            [UnlinkedConstOperation.pushString, UnlinkedConstOperation.length],
-        strings: ['abc']);
-  }
-
-  test_constExpr_makeList_typed() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = const <int>[11, 22, 33];');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeList
-    ], ints: [
-      11,
-      22,
-      33,
-      3
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_makeList_untyped() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = const [11, 22, 33];');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.makeList
-    ], ints: [
-      11,
-      22,
-      33,
-      3
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, '',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_makeMap_typed() {
-    UnlinkedVariable variable = serializeVariableText(
-        'const v = const <int, String>{11: "aaa", 22: "bbb", 33: "ccc"};');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeMap
-    ], ints: [
-      11,
-      22,
-      33,
-      3
-    ], strings: [
-      'aaa',
-      'bbb',
-      'ccc'
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
-          expectedKind: ReferenceKind.classOrEnum),
-      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_makeMap_untyped() {
-    UnlinkedVariable variable = serializeVariableText(
-        'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeMap
-    ], ints: [
-      11,
-      22,
-      33,
-      3
-    ], strings: [
-      'aaa',
-      'bbb',
-      'ccc'
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, '',
-          expectedKind: ReferenceKind.classOrEnum),
-      (TypeRef r) => checkTypeRef(r, null, null, '',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_makeSymbol() {
-    UnlinkedVariable variable = serializeVariableText('const v = #a.bb.ccc;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.makeSymbol
-    ], strings: [
-      'a.bb.ccc'
-    ]);
-  }
-
-  test_constExpr_parenthesized() {
-    UnlinkedVariable variable = serializeVariableText('const v = (1 + 2) * 3;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.add,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.multiply,
-    ], ints: [
-      1,
-      2,
-      3
-    ]);
-  }
-
-  test_constExpr_prefix_complement() {
-    UnlinkedVariable variable = serializeVariableText('const v = ~2;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators:
-            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.complement],
-        ints: [2]);
-  }
-
-  test_constExpr_prefix_negate() {
-    UnlinkedVariable variable = serializeVariableText('const v = -(2);');
-    _assertUnlinkedConst(variable.constExpr,
-        operators:
-            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.negate],
-        ints: [2]);
-  }
-
-  test_constExpr_prefix_not() {
-    UnlinkedVariable variable = serializeVariableText('const v = !true;');
-    _assertUnlinkedConst(variable.constExpr, operators:
-        [UnlinkedConstOperation.pushTrue, UnlinkedConstOperation.not]);
-  }
-
-  test_constExpr_pushDouble() {
-    UnlinkedVariable variable = serializeVariableText('const v = 123.4567;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushDouble], doubles: [123.4567]);
-  }
-
-  test_constExpr_pushFalse() {
-    UnlinkedVariable variable = serializeVariableText('const v = false;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushFalse]);
-  }
-
-  test_constExpr_pushInt() {
-    UnlinkedVariable variable = serializeVariableText('const v = 1;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
-  }
-
-  test_constExpr_pushNull() {
-    UnlinkedVariable variable = serializeVariableText('const v = null;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushNull]);
-  }
-
-  test_constExpr_pushReference_class() {
-    UnlinkedVariable variable = serializeVariableText('''
-class C {}
-const v = C;
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushReference
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_pushReference_class_field() {
-    // TODO(scheglov) Not sure for to represent a field reference
-    // using TypeRef.
-//    UnlinkedVariable variable = serializeVariableText('''
-//class C {
-//  static const int F = 1;
-//}
-//const v = C.F;
-//''');
-//    _assertUnlinkedConst(variable.constExpr, operators: [
-//      UnlinkedConstOperation.pushReference
-//    ], references: [
-//      (TypeRef r) => checkTypeRef(r, null, null, 'F',
-//          expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'C')
-//    ]);
-  }
-
-  test_constExpr_pushReference_enum() {
-    UnlinkedVariable variable = serializeVariableText('''
-enum C {V1, V2, V3}
-const v = C;
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushReference
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
-    ]);
-  }
-
-  test_constExpr_pushReference_topLevelVariable_imported() {
-    addNamedSource('/a.dart', 'const int a = 1;');
-    UnlinkedVariable variable = serializeVariableText('''
-import 'a.dart';
-const v = a;
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushReference
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
-  }
-
-  test_constExpr_pushReference_topLevelVariable_imported_withPrefix() {
-    addNamedSource('/a.dart', 'const int a = 1;');
-    UnlinkedVariable variable = serializeVariableText('''
-import 'a.dart' as p;
-const v = p.a;
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushReference
-    ], referenceValidators: [
-      (TypeRef r) {
-        return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
-            expectedKind: ReferenceKind.topLevelPropertyAccessor,
-            expectedPrefix: 'p');
-      }
-    ]);
-  }
-
-  test_constExpr_pushReference_topLevelVariable_local() {
-    // TODO(scheglov) use `a + b`
-    UnlinkedVariable variable = serializeVariableText('''
-const int a = 1;
-const v = a;
-''');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushReference
-    ], referenceValidators: [
-      (TypeRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.topLevelPropertyAccessor)
-    ]);
-  }
-
-  test_constExpr_pushString_adjacent() {
-    UnlinkedVariable variable =
-        serializeVariableText('const v = "aaa" "b" "ccc";');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushString], strings: ['aaabccc']);
-  }
-
-  test_constExpr_pushString_adjacent_interpolation() {
-    UnlinkedVariable variable =
-        serializeVariableText(r'const v = "aaa" "bb ${42} bbb" "cccc";');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.concatenate,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.concatenate,
-    ], ints: [
-      42,
-      3,
-      3,
-    ], strings: [
-      'aaa',
-      'bb ',
-      ' bbb',
-      'cccc'
-    ]);
-  }
-
-  test_constExpr_pushString_interpolation() {
-    UnlinkedVariable variable =
-        serializeVariableText(r'const v = "aaa ${42} bbb";');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.concatenate
-    ], ints: [
-      42,
-      3
-    ], strings: [
-      'aaa ',
-      ' bbb'
-    ]);
-  }
-
-  test_constExpr_pushString_simple() {
-    UnlinkedVariable variable = serializeVariableText('const v = "abc";');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushString], strings: ['abc']);
-  }
-
-  test_constExpr_pushTrue() {
-    UnlinkedVariable variable = serializeVariableText('const v = true;');
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushTrue]);
-  }
-
-  test_constructor() {
-    String text = 'class C { C(); }';
-    UnlinkedExecutable executable =
-        findExecutable('', executables: serializeClassText(text).executables);
-    expect(executable.kind, UnlinkedExecutableKind.constructor);
-    expect(executable.hasImplicitReturnType, isFalse);
-    expect(executable.isExternal, isFalse);
-    expect(executable.nameOffset, text.indexOf('C();'));
-  }
-
-  test_constructor_anonymous() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(); }').executables);
-    expect(executable.name, isEmpty);
-  }
-
-  test_constructor_const() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { const C(); }').executables);
-    expect(executable.isConst, isTrue);
-    expect(executable.isExternal, isFalse);
-  }
-
-  test_constructor_const_external() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { external const C(); }').executables);
-    expect(executable.isConst, isTrue);
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_constructor_documented() {
-    String text = '''
-class C {
-  /**
-   * Docs
-   */
-  C();
-}''';
-    UnlinkedExecutable executable = serializeClassText(text).executables[0];
-    expect(executable.documentationComment, isNotNull);
-    checkDocumentationComment(executable.documentationComment, text);
-  }
-
-  test_constructor_external() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { external C(); }').executables);
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_constructor_factory() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { factory C() => null; }').executables);
-    expect(executable.isFactory, isTrue);
-  }
-
-  test_constructor_implicit() {
-    // Implicit constructors are not serialized.
-    UnlinkedExecutable executable = findExecutable(null,
-        executables: serializeClassText('class C { C(); }').executables,
-        failIfAbsent: false);
-    expect(executable, isNull);
-  }
-
-  test_constructor_initializing_formal() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { C(this.x); final x; }').executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.isInitializingFormal, isTrue);
-  }
-
-  test_constructor_initializing_formal_explicit_type() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(int this.x); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_constructor_initializing_formal_function_typed() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(this.x()); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.isFunctionTyped, isTrue);
-  }
-
-  test_constructor_initializing_formal_function_typed_explicit_return_type() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { C(int this.x()); Function x; }')
-                .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_constructor_initializing_formal_function_typed_implicit_return_type() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(this.x()); Function x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    // Since the parameter is function-typed it is considered to have an
-    // explicit type, even though that explicit type itself has an implicit
-    // return type.
-    expect(parameter.hasImplicitType, isFalse);
-    checkDynamicTypeRef(parameter.type);
-  }
-
-  test_constructor_initializing_formal_function_typed_no_parameters() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(this.x()); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.parameters, isEmpty);
-  }
-
-  test_constructor_initializing_formal_function_typed_parameter() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(this.x(a)); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.parameters, hasLength(1));
-  }
-
-  test_constructor_initializing_formal_function_typed_parameter_order() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(this.x(a, b)); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.parameters, hasLength(2));
-    expect(parameter.parameters[0].name, 'a');
-    expect(parameter.parameters[1].name, 'b');
-  }
-
-  test_constructor_initializing_formal_implicit_type() {
-    // Note: the implicit type of an initializing formal is the type of the
-    // field.
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { C(this.x); int x; }').executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.type, isNull);
-    expect(parameter.hasImplicitType, isTrue);
-  }
-
-  test_constructor_initializing_formal_name() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { C(this.x); final x; }').executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.name, 'x');
-  }
-
-  test_constructor_initializing_formal_named() {
-    // TODO(paulberry): also test default value
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C({this.x}); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.kind, UnlinkedParamKind.named);
-  }
-
-  test_constructor_initializing_formal_non_function_typed() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { C(this.x); final x; }').executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.isFunctionTyped, isFalse);
-  }
-
-  test_constructor_initializing_formal_positional() {
-    // TODO(paulberry): also test default value
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C([this.x]); final x; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.kind, UnlinkedParamKind.positional);
-  }
-
-  test_constructor_initializing_formal_required() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables:
-            serializeClassText('class C { C(this.x); final x; }').executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.kind, UnlinkedParamKind.required);
-  }
-
-  test_constructor_initializing_formal_typedef() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText(
-                'typedef F<T>(T x); class C<X> { C(this.f); F<X> f; }')
-            .executables);
-    UnlinkedParam parameter = executable.parameters[0];
-    expect(parameter.isFunctionTyped, isFalse);
-    expect(parameter.parameters, isEmpty);
-  }
-
-  test_constructor_named() {
-    String text = 'class C { C.foo(); }';
-    UnlinkedExecutable executable = findExecutable('foo',
-        executables: serializeClassText(text).executables);
-    expect(executable.name, 'foo');
-    expect(executable.nameOffset, text.indexOf('foo'));
-  }
-
-  test_constructor_non_const() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(); }').executables);
-    expect(executable.isConst, isFalse);
-  }
-
-  test_constructor_non_factory() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(); }').executables);
-    expect(executable.isFactory, isFalse);
-  }
-
-  test_constructor_return_type() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(); }').executables);
-    expect(executable.returnType, isNull);
-  }
-
-  test_constructor_return_type_parameterized() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C<T, U> { C(); }').executables);
-    expect(executable.returnType, isNull);
-  }
-
-  test_dependencies_export_to_export_unused() {
-    // TODO(paulberry): fix this test.
-    addNamedSource('/a.dart', 'export "b.dart";');
-    addNamedSource('/b.dart', '');
-    serializeLibraryText('export "a.dart";');
-    // The main test library depends on b.dart, even though it doesn't
-    // re-export any names defined in b.dart, because a change to b.dart might
-    // cause it to start exporting a name that the main test library *does*
-    // use.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
-  }
-
-  test_dependencies_export_unused() {
-    // TODO(paulberry): fix this test.
-    addNamedSource('/a.dart', '');
-    serializeLibraryText('export "a.dart";');
-    // The main test library depends on a.dart, even though it doesn't
-    // re-export any names defined in a.dart, because a change to a.dart might
-    // cause it to start exporting a name that the main test library *will*
-    // re-export.
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
-  }
-
-  test_dependencies_import_to_export() {
-    addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
-    addNamedSource('/b.dart', 'library b;');
-    serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
-    // The main test library depends on b.dart, because names defined in
-    // b.dart are exported by a.dart.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
-  }
-
-  test_dependencies_import_to_export_in_subdirs_absolute_export() {
-    addNamedSource('/a/a.dart',
-        'library a; export "${absUri('/a/b/b.dart')}"; class A {}');
-    addNamedSource('/a/b/b.dart', 'library b;');
-    serializeLibraryText('import "a/a.dart"; A a;');
-    checkHasDependency(absUri('/a/a.dart'), 'a/a.dart');
-    // The main test library depends on b.dart, because names defined in
-    // b.dart are exported by a.dart.
-    checkHasDependency(absUri('/a/b/b.dart'), absUri('/a/b/b.dart'));
-  }
-
-  test_dependencies_import_to_export_in_subdirs_absolute_import() {
-    addNamedSource('/a/a.dart', 'library a; export "b/b.dart"; class A {}');
-    addNamedSource('/a/b/b.dart', 'library b;');
-    serializeLibraryText('import "${absUri('/a/a.dart')}"; A a;');
-    checkHasDependency(absUri('/a/a.dart'), absUri('/a/a.dart'));
-    // The main test library depends on b.dart, because names defined in
-    // b.dart are exported by a.dart.
-    checkHasDependency(absUri('/a/b/b.dart'), absUri('/a/b/b.dart'));
-  }
-
-  test_dependencies_import_to_export_in_subdirs_relative() {
-    addNamedSource('/a/a.dart', 'library a; export "b/b.dart"; class A {}');
-    addNamedSource('/a/b/b.dart', 'library b;');
-    serializeLibraryText('import "a/a.dart"; A a;');
-    checkHasDependency(absUri('/a/a.dart'), 'a/a.dart');
-    // The main test library depends on b.dart, because names defined in
-    // b.dart are exported by a.dart.
-    checkHasDependency(absUri('/a/b/b.dart'), 'a/b/b.dart');
-  }
-
-  test_dependencies_import_to_export_loop() {
-    addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
-    addNamedSource('/b.dart', 'library b; export "a.dart";');
-    serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
-    // Serialization should have been able to walk the transitive export
-    // dependencies to b.dart without going into an infinite loop.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
-  }
-
-  test_dependencies_import_to_export_transitive_closure() {
-    addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
-    addNamedSource('/b.dart', 'library b; export "c.dart";');
-    addNamedSource('/c.dart', 'library c;');
-    serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
-    // The main test library depends on c.dart, because names defined in
-    // c.dart are exported by b.dart and then re-exported by a.dart.
-    checkHasDependency(absUri('/c.dart'), 'c.dart');
-  }
-
-  test_dependencies_import_to_export_unused() {
-    addNamedSource('/a.dart', 'export "b.dart";');
-    addNamedSource('/b.dart', '');
-    serializeLibraryText('import "a.dart";', allowErrors: true);
-    // The main test library depends on b.dart, even though it doesn't use any
-    // names defined in b.dart, because a change to b.dart might cause it to
-    // start exporting a name that the main test library *does* use.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
-  }
-
-  test_dependencies_import_transitive_closure() {
-    addNamedSource(
-        '/a.dart', 'library a; import "b.dart"; class A extends B {}');
-    addNamedSource('/b.dart', 'library b; class B {}');
-    serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
-    // The main test library doesn't depend on b.dart, because no change to
-    // b.dart can possibly affect the serialized element model for it.
-    checkLacksDependency(absUri('/b.dart'), 'b.dart');
-  }
-
-  test_dependencies_import_unused() {
-    addNamedSource('/a.dart', '');
-    serializeLibraryText('import "a.dart";', allowErrors: true);
-    // The main test library depends on a.dart, even though it doesn't use any
-    // names defined in a.dart, because a change to a.dart might cause it to
-    // start exporting a name that the main test library *does* use.
-    checkHasDependency(absUri('/a.dart'), 'a.dart');
-  }
-
-  test_dependencies_parts() {
-    addNamedSource(
-        '/a.dart', 'library a; part "b.dart"; part "c.dart"; class A {}');
-    addNamedSource('/b.dart', 'part of a;');
-    addNamedSource('/c.dart', 'part of a;');
-    serializeLibraryText('import "a.dart"; A a;');
-    int dep = checkHasDependency(absUri('/a.dart'), 'a.dart');
-    checkDependencyParts(linked.dependencies[dep],
-        [absUri('/b.dart'), absUri('/c.dart')], ['b.dart', 'c.dart']);
-  }
-
-  test_dependencies_parts_relative_to_importing_library() {
-    addNamedSource('/a/b.dart', 'export "c/d.dart";');
-    addNamedSource('/a/c/d.dart',
-        'library d; part "e/f.dart"; part "g/h.dart"; class D {}');
-    addNamedSource('/a/c/e/f.dart', 'part of d;');
-    addNamedSource('/a/c/g/h.dart', 'part of d;');
-    serializeLibraryText('import "a/b.dart"; D d;');
-    int dep = checkHasDependency(absUri('/a/c/d.dart'), 'a/c/d.dart');
-    checkDependencyParts(
-        linked.dependencies[dep],
-        [absUri('/a/c/e/f.dart'), absUri('/a/c/g/h.dart')],
-        ['a/c/e/f.dart', 'a/c/g/h.dart']);
-  }
-
-  test_elements_in_part() {
-    addNamedSource(
-        '/part1.dart',
-        '''
-part of my.lib;
-
-class C {}
-enum E { v }
-var v;
-f() {}
-typedef F();
-''');
-    serializeLibraryText('library my.lib; part "part1.dart";');
-    UnlinkedUnit unit = unlinkedUnits[1];
-    expect(findClass('C', unit: unit), isNotNull);
-    expect(findEnum('E', unit: unit), isNotNull);
-    expect(findVariable('v', variables: unit.variables), isNotNull);
-    expect(findExecutable('f', executables: unit.executables), isNotNull);
-    expect(findTypedef('F', unit: unit), isNotNull);
-  }
-
-  test_enum() {
-    String text = 'enum E { v1 }';
-    UnlinkedEnum e = serializeEnumText(text);
-    expect(e.name, 'E');
-    expect(e.nameOffset, text.indexOf('E'));
-    expect(e.values, hasLength(1));
-    expect(e.values[0].name, 'v1');
-    expect(e.values[0].nameOffset, text.indexOf('v1'));
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.classOrEnum);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'E');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
-  }
-
-  test_enum_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-enum E { v }''';
-    UnlinkedEnum enm = serializeEnumText(text);
-    expect(enm.documentationComment, isNotNull);
-    checkDocumentationComment(enm.documentationComment, text);
-  }
-
-  test_enum_order() {
-    UnlinkedEnum e = serializeEnumText('enum E { v1, v2 }');
-    expect(e.values, hasLength(2));
-    expect(e.values[0].name, 'v1');
-    expect(e.values[1].name, 'v2');
-  }
-
-  test_enum_private() {
-    serializeEnumText('enum _E { v1 }', '_E');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_executable_abstract() {
-    UnlinkedExecutable executable =
-        serializeClassText('abstract class C { f(); }').executables[0];
-    expect(executable.isAbstract, isTrue);
-  }
-
-  test_executable_concrete() {
-    UnlinkedExecutable executable =
-        serializeClassText('abstract class C { f() {} }').executables[0];
-    expect(executable.isAbstract, isFalse);
-  }
-
-  test_executable_function() {
-    String text = '  f() {}';
-    UnlinkedExecutable executable = serializeExecutableText(text);
-    expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.hasImplicitReturnType, isTrue);
-    checkDynamicTypeRef(executable.returnType);
-    expect(executable.isExternal, isFalse);
-    expect(executable.nameOffset, text.indexOf('f'));
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.topLevelFunction);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
-  }
-
-  test_executable_function_explicit_return() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('dynamic f() => null;');
-    expect(executable.hasImplicitReturnType, isFalse);
-    checkDynamicTypeRef(executable.returnType);
-  }
-
-  test_executable_function_external() {
-    UnlinkedExecutable executable = serializeExecutableText('external f();');
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_executable_function_private() {
-    serializeExecutableText('_f() {}', '_f');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_executable_getter() {
-    String text = 'int get f => 1;';
-    UnlinkedExecutable executable = serializeExecutableText(text);
-    expect(executable.kind, UnlinkedExecutableKind.getter);
-    expect(executable.hasImplicitReturnType, isFalse);
-    expect(executable.isExternal, isFalse);
-    expect(executable.nameOffset, text.indexOf('f'));
-    expect(findVariable('f'), isNull);
-    expect(findExecutable('f='), isNull);
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.topLevelPropertyAccessor);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
-  }
-
-  test_executable_getter_external() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('external int get f;');
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_executable_getter_private() {
-    serializeExecutableText('int get _f => 1;', '_f');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_executable_getter_type() {
-    UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
-    checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
-    expect(executable.parameters, isEmpty);
-  }
-
-  test_executable_getter_type_implicit() {
-    UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
-    checkDynamicTypeRef(executable.returnType);
-    expect(executable.hasImplicitReturnType, isTrue);
-    expect(executable.parameters, isEmpty);
-  }
-
-  test_executable_member_function() {
-    UnlinkedExecutable executable = findExecutable('f',
-        executables: serializeClassText('class C { f() {} }').executables);
-    expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.hasImplicitReturnType, isTrue);
-    expect(executable.isExternal, isFalse);
-  }
-
-  test_executable_member_function_explicit_return() {
-    UnlinkedExecutable executable = findExecutable('f',
-        executables:
-            serializeClassText('class C { dynamic f() => null; }').executables);
-    expect(executable.hasImplicitReturnType, isFalse);
-  }
-
-  test_executable_member_function_external() {
-    UnlinkedExecutable executable = findExecutable('f',
-        executables:
-            serializeClassText('class C { external f(); }').executables);
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_executable_member_getter() {
-    UnlinkedClass cls = serializeClassText('class C { int get f => 1; }');
-    UnlinkedExecutable executable =
-        findExecutable('f', executables: cls.executables, failIfAbsent: true);
-    expect(executable.kind, UnlinkedExecutableKind.getter);
-    expect(executable.hasImplicitReturnType, isFalse);
-    expect(executable.isExternal, isFalse);
-    expect(findVariable('f', variables: cls.fields), isNull);
-    expect(findExecutable('f=', executables: cls.executables), isNull);
-  }
-
-  test_executable_member_getter_external() {
-    UnlinkedClass cls = serializeClassText('class C { external int get f; }');
-    UnlinkedExecutable executable =
-        findExecutable('f', executables: cls.executables, failIfAbsent: true);
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_executable_member_setter() {
-    UnlinkedClass cls = serializeClassText('class C { void set f(value) {} }');
-    UnlinkedExecutable executable =
-        findExecutable('f=', executables: cls.executables, failIfAbsent: true);
-    expect(executable.kind, UnlinkedExecutableKind.setter);
-    expect(executable.hasImplicitReturnType, isFalse);
-    expect(executable.isExternal, isFalse);
-    expect(findVariable('f', variables: cls.fields), isNull);
-    expect(findExecutable('f', executables: cls.executables), isNull);
-  }
-
-  test_executable_member_setter_external() {
-    UnlinkedClass cls =
-        serializeClassText('class C { external void set f(value); }');
-    UnlinkedExecutable executable =
-        findExecutable('f=', executables: cls.executables, failIfAbsent: true);
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_executable_member_setter_implicit_return() {
-    UnlinkedClass cls = serializeClassText('class C { set f(value) {} }');
-    UnlinkedExecutable executable =
-        findExecutable('f=', executables: cls.executables, failIfAbsent: true);
-    expect(executable.hasImplicitReturnType, isTrue);
-    checkDynamicTypeRef(executable.returnType);
-  }
-
-  test_executable_name() {
-    UnlinkedExecutable executable = serializeExecutableText('f() {}');
-    expect(executable.name, 'f');
-  }
-
-  test_executable_no_flags() {
-    UnlinkedExecutable executable = serializeExecutableText('f() {}');
-    expect(executable.isAbstract, isFalse);
-    expect(executable.isConst, isFalse);
-    expect(executable.isFactory, isFalse);
-    expect(executable.isStatic, isFalse);
-  }
-
-  test_executable_non_static() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { f() {} }').executables[0];
-    expect(executable.isStatic, isFalse);
-  }
-
-  test_executable_non_static_top_level() {
-    // Top level executables are considered non-static.
-    UnlinkedExecutable executable = serializeExecutableText('f() {}');
-    expect(executable.isStatic, isFalse);
-  }
-
-  test_executable_operator() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { C operator+(C c) => null; }').executables[
-            0];
-    expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.name, '+');
-    expect(executable.hasImplicitReturnType, false);
-    expect(executable.isAbstract, false);
-    expect(executable.isConst, false);
-    expect(executable.isFactory, false);
-    expect(executable.isStatic, false);
-    expect(executable.parameters, hasLength(1));
-    checkTypeRef(executable.returnType, null, null, 'C');
-    expect(executable.typeParameters, isEmpty);
-    expect(executable.isExternal, false);
-  }
-
-  test_executable_operator_equal() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { bool operator==(C other) => false; }')
-            .executables[0];
-    expect(executable.name, '==');
-  }
-
-  test_executable_operator_external() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { external C operator+(C c); }')
-            .executables[0];
-    expect(executable.isExternal, true);
-  }
-
-  test_executable_operator_greater_equal() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { bool operator>=(C other) => false; }')
-            .executables[0];
-    expect(executable.name, '>=');
-  }
-
-  test_executable_operator_index() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { bool operator[](int i) => null; }')
-            .executables[0];
-    expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.name, '[]');
-    expect(executable.hasImplicitReturnType, false);
-    expect(executable.isAbstract, false);
-    expect(executable.isConst, false);
-    expect(executable.isFactory, false);
-    expect(executable.isStatic, false);
-    expect(executable.parameters, hasLength(1));
-    checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
-    expect(executable.typeParameters, isEmpty);
-  }
-
-  test_executable_operator_index_set() {
-    UnlinkedExecutable executable = serializeClassText(
-        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
-    expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
-    expect(executable.name, '[]=');
-    expect(executable.hasImplicitReturnType, false);
-    expect(executable.isAbstract, false);
-    expect(executable.isConst, false);
-    expect(executable.isFactory, false);
-    expect(executable.isStatic, false);
-    expect(executable.parameters, hasLength(2));
-    expect(executable.returnType, isNull);
-    expect(executable.typeParameters, isEmpty);
-  }
-
-  test_executable_operator_less_equal() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { bool operator<=(C other) => false; }')
-            .executables[0];
-    expect(executable.name, '<=');
-  }
-
-  test_executable_param_function_typed() {
-    UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
-    expect(executable.parameters[0].isFunctionTyped, isTrue);
-    // Since the parameter is function-typed it is considered to have an
-    // explicit type, even though that explicit type itself has an implicit
-    // return type.
-    expect(executable.parameters[0].hasImplicitType, isFalse);
-  }
-
-  test_executable_param_function_typed_explicit_return_type() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('f(dynamic g()) {}');
-    expect(executable.parameters[0].hasImplicitType, isFalse);
-  }
-
-  test_executable_param_function_typed_param() {
-    UnlinkedExecutable executable = serializeExecutableText('f(g(x)) {}');
-    expect(executable.parameters[0].parameters, hasLength(1));
-  }
-
-  test_executable_param_function_typed_param_none() {
-    UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
-    expect(executable.parameters[0].parameters, isEmpty);
-  }
-
-  test_executable_param_function_typed_param_order() {
-    UnlinkedExecutable executable = serializeExecutableText('f(g(x, y)) {}');
-    expect(executable.parameters[0].parameters, hasLength(2));
-    expect(executable.parameters[0].parameters[0].name, 'x');
-    expect(executable.parameters[0].parameters[1].name, 'y');
-  }
-
-  test_executable_param_function_typed_return_type() {
-    UnlinkedExecutable executable = serializeExecutableText('f(int g()) {}');
-    checkTypeRef(
-        executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_executable_param_function_typed_return_type_implicit() {
-    UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
-    checkDynamicTypeRef(executable.parameters[0].type);
-  }
-
-  test_executable_param_function_typed_return_type_void() {
-    UnlinkedExecutable executable = serializeExecutableText('f(void g()) {}');
-    expect(executable.parameters[0].type, isNull);
-  }
-
-  test_executable_param_kind_named() {
-    UnlinkedExecutable executable = serializeExecutableText('f({x}) {}');
-    expect(executable.parameters[0].kind, UnlinkedParamKind.named);
-  }
-
-  test_executable_param_kind_positional() {
-    UnlinkedExecutable executable = serializeExecutableText('f([x]) {}');
-    expect(executable.parameters[0].kind, UnlinkedParamKind.positional);
-  }
-
-  test_executable_param_kind_required() {
-    UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
-    expect(executable.parameters[0].kind, UnlinkedParamKind.required);
-  }
-
-  test_executable_param_name() {
-    String text = 'f(x) {}';
-    UnlinkedExecutable executable = serializeExecutableText(text);
-    expect(executable.parameters, hasLength(1));
-    expect(executable.parameters[0].name, 'x');
-    expect(executable.parameters[0].nameOffset, text.indexOf('x'));
-  }
-
-  test_executable_param_no_flags() {
-    UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
-    expect(executable.parameters[0].isFunctionTyped, isFalse);
-    expect(executable.parameters[0].isInitializingFormal, isFalse);
-  }
-
-  test_executable_param_non_function_typed() {
-    UnlinkedExecutable executable = serializeExecutableText('f(g) {}');
-    expect(executable.parameters[0].isFunctionTyped, isFalse);
-  }
-
-  test_executable_param_none() {
-    UnlinkedExecutable executable = serializeExecutableText('f() {}');
-    expect(executable.parameters, isEmpty);
-  }
-
-  test_executable_param_order() {
-    UnlinkedExecutable executable = serializeExecutableText('f(x, y) {}');
-    expect(executable.parameters, hasLength(2));
-    expect(executable.parameters[0].name, 'x');
-    expect(executable.parameters[1].name, 'y');
-  }
-
-  test_executable_param_type_explicit() {
-    UnlinkedExecutable executable = serializeExecutableText('f(dynamic x) {}');
-    checkDynamicTypeRef(executable.parameters[0].type);
-    expect(executable.parameters[0].hasImplicitType, isFalse);
-  }
-
-  test_executable_param_type_implicit() {
-    UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
-    checkDynamicTypeRef(executable.parameters[0].type);
-    expect(executable.parameters[0].hasImplicitType, isTrue);
-  }
-
-  test_executable_return_type() {
-    UnlinkedExecutable executable = serializeExecutableText('int f() => 1;');
-    checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
-    expect(executable.hasImplicitReturnType, isFalse);
-  }
-
-  test_executable_return_type_implicit() {
-    UnlinkedExecutable executable = serializeExecutableText('f() {}');
-    checkDynamicTypeRef(executable.returnType);
-    expect(executable.hasImplicitReturnType, isTrue);
-  }
-
-  test_executable_return_type_void() {
-    UnlinkedExecutable executable = serializeExecutableText('void f() {}');
-    expect(executable.returnType, isNull);
-  }
-
-  test_executable_setter() {
-    String text = 'void set f(value) {}';
-    UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
-    expect(executable.kind, UnlinkedExecutableKind.setter);
-    expect(executable.hasImplicitReturnType, isFalse);
-    expect(executable.isExternal, isFalse);
-    expect(executable.nameOffset, text.indexOf('f'));
-    expect(findVariable('f'), isNull);
-    expect(findExecutable('f'), isNull);
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.topLevelPropertyAccessor);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f=');
-  }
-
-  test_executable_setter_external() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('external void set f(value);', 'f=');
-    expect(executable.isExternal, isTrue);
-  }
-
-  test_executable_setter_implicit_return() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('set f(value) {}', 'f=');
-    expect(executable.hasImplicitReturnType, isTrue);
-    checkDynamicTypeRef(executable.returnType);
-  }
-
-  test_executable_setter_private() {
-    serializeExecutableText('void set _f(value) {}', '_f=');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_executable_setter_type() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('void set f(int value) {}', 'f=');
-    expect(executable.returnType, isNull);
-    expect(executable.parameters, hasLength(1));
-    expect(executable.parameters[0].name, 'value');
-    checkTypeRef(
-        executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_executable_static() {
-    UnlinkedExecutable executable =
-        serializeClassText('class C { static f() {} }').executables[0];
-    expect(executable.isStatic, isTrue);
-  }
-
-  test_executable_type_param_f_bound_function() {
-    UnlinkedExecutable ex =
-        serializeExecutableText('void f<T, U extends List<T>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
-    checkParamTypeRef(typeArgument, 2);
-  }
-
-  test_executable_type_param_f_bound_method() {
-    UnlinkedExecutable ex =
-        serializeMethodText('void f<T, U extends List<T>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
-    checkParamTypeRef(typeArgument, 2);
-  }
-
-  test_executable_type_param_f_bound_self_ref_function() {
-    UnlinkedExecutable ex =
-        serializeExecutableText('void f<T, U extends List<U>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
-    checkParamTypeRef(typeArgument, 1);
-  }
-
-  test_executable_type_param_f_bound_self_ref_method() {
-    UnlinkedExecutable ex =
-        serializeMethodText('void f<T, U extends List<U>>() {}');
-    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
-    checkParamTypeRef(typeArgument, 1);
-  }
-
-  test_executable_type_param_in_parameter_function() {
-    UnlinkedExecutable ex = serializeExecutableText('void f<T>(T t) {}');
-    checkParamTypeRef(ex.parameters[0].type, 1);
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
-  }
-
-  test_executable_type_param_in_parameter_method() {
-    UnlinkedExecutable ex = serializeMethodText('void f<T>(T t) {}');
-    checkParamTypeRef(ex.parameters[0].type, 1);
-  }
-
-  test_executable_type_param_in_return_type_function() {
-    UnlinkedExecutable ex = serializeExecutableText('T f<T>() => null;');
-    checkParamTypeRef(ex.returnType, 1);
-  }
-
-  test_executable_type_param_in_return_type_method() {
-    UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
-    checkParamTypeRef(ex.returnType, 1);
-  }
-
-  test_export_class() {
-    addNamedSource('/a.dart', 'class C {}');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
-        ReferenceKind.classOrEnum);
-  }
-
-  test_export_class_alias() {
-    addNamedSource(
-        '/a.dart', 'class C extends _D with _E {} class _D {} class _E {}');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
-        ReferenceKind.classOrEnum);
-  }
-
-  test_export_enum() {
-    addNamedSource('/a.dart', 'enum E { v }');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'E',
-        ReferenceKind.classOrEnum);
-  }
-
-  test_export_from_part() {
-    addNamedSource('/a.dart', 'library foo; part "b.dart";');
-    addNamedSource('/b.dart', 'part of foo; f() {}');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        ReferenceKind.topLevelFunction,
-        expectedTargetUnit: 1);
-  }
-
-  test_export_function() {
-    addNamedSource('/a.dart', 'f() {}');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        ReferenceKind.topLevelFunction);
-  }
-
-  test_export_getter() {
-    addNamedSource('/a.dart', 'get f => null');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        ReferenceKind.topLevelPropertyAccessor);
-  }
-
-  test_export_hide() {
-    addNamedSource('/a.dart', 'f() {} g() {}');
-    serializeLibraryText('export "a.dart" hide g;');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        ReferenceKind.topLevelFunction);
-  }
-
-  test_export_hide_order() {
-    serializeLibraryText('export "dart:async" hide Future, Stream;');
-    expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
-    expect(
-        unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
-        isEmpty);
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
-        hasLength(2));
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[0],
-        'Future');
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[1],
-        'Stream');
-    expect(linked.exportNames, isNotEmpty);
-  }
-
-  test_export_names_excludes_names_from_library() {
-    addNamedSource('/a.dart', 'part of my.lib; int y; int _y;');
-    serializeLibraryText('library my.lib; part "a.dart"; int x; int _x;');
-    expect(linked.exportNames, isEmpty);
-  }
-
-  test_export_no_combinators() {
-    serializeLibraryText('export "dart:async";');
-    expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators, isEmpty);
-  }
-
-  test_export_not_shadowed_by_prefix() {
-    addNamedSource('/a.dart', 'f() {}');
-    serializeLibraryText('export "a.dart"; import "dart:core" as f; f.int _x;');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        ReferenceKind.topLevelFunction);
-  }
-
-  test_export_offset() {
-    String libraryText = '    export "dart:async";';
-    serializeLibraryText(libraryText);
-    expect(unlinkedUnits[0].exports[0].uriOffset,
-        libraryText.indexOf('"dart:async"'));
-    expect(unlinkedUnits[0].exports[0].uriEnd, libraryText.indexOf(';'));
-    expect(unlinkedUnits[0].exports[0].offset, libraryText.indexOf('export'));
-  }
-
-  test_export_private() {
-    // Private names should not be exported.
-    addNamedSource('/a.dart', '_f() {}');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, isEmpty);
-  }
-
-  test_export_setter() {
-    addNamedSource('/a.dart', 'void set f(value) {}');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f=',
-        ReferenceKind.topLevelPropertyAccessor);
-  }
-
-  test_export_shadowed() {
-    // f() is not shown in exportNames because it is already defined at top
-    // level in the library.
-    addNamedSource('/a.dart', 'f() {}');
-    serializeLibraryText('export "a.dart"; f() {}');
-    expect(linked.exportNames, isEmpty);
-  }
-
-  test_export_shadowed_variable() {
-    // Neither `v` nor `v=` is shown in exportNames because both are defined at
-    // top level in the library by the declaration `var v;`.
-    addNamedSource('/a.dart', 'var v;');
-    serializeLibraryText('export "a.dart"; var v;');
-    expect(linked.exportNames, isEmpty);
-  }
-
-  test_export_shadowed_variable_const() {
-    // `v=` is shown in exportNames because the top level declaration
-    // `const v = 0;` only shadows `v`, not `v=`.
-    addNamedSource('/a.dart', 'var v;');
-    serializeLibraryText('export "a.dart"; const v = 0;');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
-        ReferenceKind.topLevelPropertyAccessor);
-  }
-
-  test_export_shadowed_variable_final() {
-    // `v=` is shown in exportNames because the top level declaration
-    // `final v = 0;` only shadows `v`, not `v=`.
-    addNamedSource('/a.dart', 'var v;');
-    serializeLibraryText('export "a.dart"; final v = 0;');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
-        ReferenceKind.topLevelPropertyAccessor);
-  }
-
-  test_export_show() {
-    addNamedSource('/a.dart', 'f() {} g() {}');
-    serializeLibraryText('export "a.dart" show f;');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
-        ReferenceKind.topLevelFunction);
-  }
-
-  test_export_show_order() {
-    serializeLibraryText('export "dart:async" show Future, Stream;');
-    expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
-    expect(
-        unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
-        hasLength(2));
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
-        isEmpty);
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[0],
-        'Future');
-    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[1],
-        'Stream');
-  }
-
-  test_export_typedef() {
-    addNamedSource('/a.dart', 'typedef F();');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'F',
-        ReferenceKind.typedef);
-  }
-
-  test_export_uri() {
-    addNamedSource('/a.dart', 'library my.lib;');
-    String uriString = '"a.dart"';
-    String libraryText = 'export $uriString;';
-    serializeLibraryText(libraryText);
-    expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.exports[0].uri, 'a.dart');
-  }
-
-  test_export_variable() {
-    addNamedSource('/a.dart', 'var v;');
-    serializeLibraryText('export "a.dart";');
-    expect(linked.exportNames, hasLength(2));
-    LinkedExportName getter =
-        linked.exportNames.firstWhere((e) => e.name == 'v');
-    expect(getter, isNotNull);
-    checkExportName(getter, absUri('/a.dart'), 'a.dart', 'v',
-        ReferenceKind.topLevelPropertyAccessor);
-    LinkedExportName setter =
-        linked.exportNames.firstWhere((e) => e.name == 'v=');
-    expect(setter, isNotNull);
-    checkExportName(setter, absUri('/a.dart'), 'a.dart', 'v=',
-        ReferenceKind.topLevelPropertyAccessor);
-  }
-
-  test_field() {
-    UnlinkedClass cls = serializeClassText('class C { int i; }');
-    UnlinkedVariable variable = findVariable('i', variables: cls.fields);
-    expect(variable, isNotNull);
-    expect(variable.isConst, isFalse);
-    expect(variable.isStatic, isFalse);
-    expect(variable.isFinal, isFalse);
-    expect(findExecutable('i', executables: cls.executables), isNull);
-    expect(findExecutable('i=', executables: cls.executables), isNull);
-  }
-
-  test_field_const() {
-    UnlinkedVariable variable =
-        serializeClassText('class C { static const int i = 0; }').fields[0];
-    expect(variable.isConst, isTrue);
-    _assertUnlinkedConst(variable.constExpr,
-        operators: [UnlinkedConstOperation.pushInt], ints: [0]);
-  }
-
-  test_field_documented() {
-    String text = '''
-class C {
-  /**
-   * Docs
-   */
-  var v;
-}''';
-    UnlinkedVariable variable = serializeClassText(text).fields[0];
-    expect(variable.documentationComment, isNotNull);
-    checkDocumentationComment(variable.documentationComment, text);
-  }
-
-  test_field_final() {
-    UnlinkedVariable variable =
-        serializeClassText('class C { final int i = 0; }').fields[0];
-    expect(variable.isFinal, isTrue);
-  }
-
-  test_field_propagated_type_final_immediate() {
-    UnlinkedVariable v =
-        serializeClassText('class C { final v = 0; }').fields[0];
-    checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_field_static() {
-    UnlinkedVariable variable =
-        serializeClassText('class C { static int i; }').fields[0];
-    expect(variable.isStatic, isTrue);
-  }
-
-  test_fully_linked_references_follow_other_references() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    serializeLibraryText('final x = 0; String y;');
-    checkLinkedTypeSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot,
-        'dart:core', 'dart:core', 'int');
-    checkTypeRef(
-        unlinkedUnits[0].variables[1].type, 'dart:core', 'dart:core', 'String');
-    // Even though the definition of y follows the definition of x, the linked
-    // type reference for x should use a higher numbered reference than the
-    // unlinked type reference for y.
-    TypeRef propagatedType =
-        getTypeRefForSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot);
-    expect(unlinkedUnits[0].variables[1].type.reference,
-        lessThan(propagatedType.reference));
-  }
-
-  test_function_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-f() {}''';
-    UnlinkedExecutable executable = serializeExecutableText(text);
-    expect(executable.documentationComment, isNotNull);
-    checkDocumentationComment(executable.documentationComment, text);
-  }
-
-  test_generic_method_in_generic_class() {
-    UnlinkedClass cls = serializeClassText(
-        'class C<T, U> { void m<V, W>(T t, U u, V v, W w) {} }');
-    List<UnlinkedParam> params = cls.executables[0].parameters;
-    checkParamTypeRef(params[0].type, 4);
-    checkParamTypeRef(params[1].type, 3);
-    checkParamTypeRef(params[2].type, 2);
-    checkParamTypeRef(params[3].type, 1);
-  }
-
-  test_getter_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-get f => null;''';
-    UnlinkedExecutable executable = serializeExecutableText(text);
-    expect(executable.documentationComment, isNotNull);
-    checkDocumentationComment(executable.documentationComment, text);
-  }
-
-  test_implicit_dependencies_follow_other_dependencies() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    addNamedSource('/a.dart', 'import "b.dart"; class C {} D f() => null;');
-    addNamedSource('/b.dart', 'class D {}');
-    serializeLibraryText('import "a.dart"; final x = f(); C y;');
-    // The dependency on b.dart is implicit, so it should be placed at the end
-    // of the dependency list, after a.dart, even though the code that refers
-    // to b.dart comes before the code that refers to a.dart.
-    int aDep =
-        checkHasDependency(absUri('/a.dart'), 'a.dart', fullyLinked: false);
-    int bDep =
-        checkHasDependency(absUri('/b.dart'), 'b.dart', fullyLinked: true);
-    expect(aDep, lessThan(bDep));
-  }
-
-  test_import_deferred() {
-    serializeLibraryText(
-        'import "dart:async" deferred as a; main() { print(a.Future); }');
-    expect(unlinkedUnits[0].imports[0].isDeferred, isTrue);
-  }
-
-  test_import_dependency() {
-    serializeLibraryText('import "dart:async"; Future x;');
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    checkDependency(linked.importDependencies[0], 'dart:async', 'dart:async');
-  }
-
-  test_import_explicit() {
-    serializeLibraryText('import "dart:core"; int i;');
-    expect(unlinkedUnits[0].imports, hasLength(1));
-    expect(unlinkedUnits[0].imports[0].isImplicit, isFalse);
-  }
-
-  test_import_hide_order() {
-    serializeLibraryText(
-        'import "dart:async" hide Future, Stream; Completer c;');
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].combinators, hasLength(1));
-    expect(unlinkedUnits[0].imports[0].combinators[0].shows, isEmpty);
-    expect(unlinkedUnits[0].imports[0].combinators[0].hides, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].combinators[0].hides[0], 'Future');
-    expect(unlinkedUnits[0].imports[0].combinators[0].hides[1], 'Stream');
-  }
-
-  test_import_implicit() {
-    // The implicit import of dart:core is represented in the model.
-    serializeLibraryText('');
-    expect(unlinkedUnits[0].imports, hasLength(1));
-    checkDependency(linked.importDependencies[0], 'dart:core', 'dart:core');
-    expect(unlinkedUnits[0].imports[0].uri, isEmpty);
-    expect(unlinkedUnits[0].imports[0].uriOffset, 0);
-    expect(unlinkedUnits[0].imports[0].uriEnd, 0);
-    expect(unlinkedUnits[0].imports[0].prefixReference, 0);
-    expect(unlinkedUnits[0].imports[0].combinators, isEmpty);
-    expect(unlinkedUnits[0].imports[0].isImplicit, isTrue);
-  }
-
-  test_import_missing() {
-    if (!checkAstDerivedData) {
-      // TODO(paulberry): At the moment unresolved imports are not included in
-      // the element model, so we can't pass this test.
-      return;
-    }
-    // Unresolved imports are included since this is necessary for proper
-    // dependency tracking.
-    allowMissingFiles = true;
-    serializeLibraryText('import "foo.dart";', allowErrors: true);
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    checkDependency(
-        linked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
-  }
-
-  test_import_no_combinators() {
-    serializeLibraryText('import "dart:async"; Future x;');
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].combinators, isEmpty);
-  }
-
-  test_import_no_flags() {
-    serializeLibraryText('import "dart:async"; Future x;');
-    expect(unlinkedUnits[0].imports[0].isImplicit, isFalse);
-    expect(unlinkedUnits[0].imports[0].isDeferred, isFalse);
-  }
-
-  test_import_non_deferred() {
-    serializeLibraryText(
-        'import "dart:async" as a; main() { print(a.Future); }');
-    expect(unlinkedUnits[0].imports[0].isDeferred, isFalse);
-  }
-
-  test_import_of_file_with_missing_part() {
-    // Other references in foo.dart should be resolved even though foo.dart's
-    // part declaration for bar.dart refers to a non-existent file.
-    allowMissingFiles = true;
-    addNamedSource('/foo.dart', 'part "bar.dart"; class C {}');
-    serializeLibraryText('import "foo.dart"; C x;');
-    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
-  }
-
-  test_import_of_missing_export() {
-    // Other references in foo.dart should be resolved even though foo.dart's
-    // re-export of bar.dart refers to a non-existent file.
-    allowMissingFiles = true;
-    addNamedSource('/foo.dart', 'export "bar.dart"; class C {}');
-    serializeLibraryText('import "foo.dart"; C x;');
-    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
-  }
-
-  test_import_offset() {
-    String libraryText = '    import "dart:async"; Future x;';
-    serializeLibraryText(libraryText);
-    expect(unlinkedUnits[0].imports[0].offset, libraryText.indexOf('import'));
-    expect(unlinkedUnits[0].imports[0].uriOffset,
-        libraryText.indexOf('"dart:async"'));
-    expect(unlinkedUnits[0].imports[0].uriEnd, libraryText.indexOf('; Future'));
-  }
-
-  test_import_prefix_name() {
-    String libraryText = 'import "dart:async" as a; a.Future x;';
-    serializeLibraryText(libraryText);
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    checkPrefix(unlinkedUnits[0].imports[0].prefixReference, 'a');
-    expect(unlinkedUnits[0].imports[0].prefixOffset, libraryText.indexOf('a;'));
-  }
-
-  test_import_prefix_none() {
-    serializeLibraryText('import "dart:async"; Future x;');
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].prefixReference, 0);
-  }
-
-  test_import_prefix_not_in_public_namespace() {
-    serializeLibraryText('import "dart:async" as a; a.Future v;');
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'v');
-    expect(unlinkedUnits[0].publicNamespace.names[1].name, 'v=');
-  }
-
-  test_import_prefix_reference() {
-    UnlinkedVariable variable =
-        serializeVariableText('import "dart:async" as a; a.Future v;');
-    checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
-        expectedPrefix: 'a', numTypeParameters: 1);
-  }
-
-  test_import_prefixes_take_precedence_over_imported_names() {
-    addNamedSource('/a.dart', 'class b {} class A');
-    addNamedSource('/b.dart', 'class Cls {}');
-    addNamedSource('/c.dart', 'class Cls {}');
-    addNamedSource('/d.dart', 'class c {} class D');
-    serializeLibraryText('''
-import 'a.dart';
-import 'b.dart' as b;
-import 'c.dart' as c;
-import 'd.dart';
-A aCls;
-b.Cls bCls;
-c.Cls cCls;
-D dCls;
-''');
-    checkTypeRef(findVariable('aCls').type, absUri('/a.dart'), 'a.dart', 'A');
-    checkTypeRef(findVariable('bCls').type, absUri('/b.dart'), 'b.dart', 'Cls',
-        expectedPrefix: 'b');
-    checkTypeRef(findVariable('cCls').type, absUri('/c.dart'), 'c.dart', 'Cls',
-        expectedPrefix: 'c');
-    checkTypeRef(findVariable('dCls').type, absUri('/d.dart'), 'd.dart', 'D');
-  }
-
-  test_import_reference() {
-    UnlinkedVariable variable =
-        serializeVariableText('import "dart:async"; Future v;');
-    checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
-        numTypeParameters: 1);
-  }
-
-  test_import_reference_merged_no_prefix() {
-    serializeLibraryText('''
-import "dart:async" show Future;
-import "dart:async" show Stream;
-
-Future f;
-Stream s;
-''');
-    checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
-        numTypeParameters: 1);
-    checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
-        numTypeParameters: 1);
-  }
-
-  test_import_reference_merged_prefixed() {
-    serializeLibraryText('''
-import "dart:async" as a show Future;
-import "dart:async" as a show Stream;
-
-a.Future f;
-a.Stream s;
-''');
-    checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
-        expectedPrefix: 'a', numTypeParameters: 1);
-    checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
-        expectedPrefix: 'a', numTypeParameters: 1);
-  }
-
-  test_import_reference_merged_prefixed_separate_libraries() {
-    addNamedSource('/a.dart', 'class A {}');
-    addNamedSource('/b.dart', 'class B {}');
-    serializeLibraryText('''
-import 'a.dart' as p;
-import 'b.dart' as p;
-
-p.A a;
-p.B b;
-''');
-    checkTypeRef(findVariable('a').type, absUri('/a.dart'), 'a.dart', 'A',
-        expectedPrefix: 'p');
-    checkTypeRef(findVariable('b').type, absUri('/b.dart'), 'b.dart', 'B',
-        expectedPrefix: 'p');
-  }
-
-  test_import_show_order() {
-    String libraryText =
-        'import "dart:async" show Future, Stream; Future x; Stream y;';
-    serializeLibraryText(libraryText);
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].combinators, hasLength(1));
-    expect(unlinkedUnits[0].imports[0].combinators[0].shows, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].combinators[0].hides, isEmpty);
-    expect(unlinkedUnits[0].imports[0].combinators[0].shows[0], 'Future');
-    expect(unlinkedUnits[0].imports[0].combinators[0].shows[1], 'Stream');
-  }
-
-  test_import_uri() {
-    String uriString = '"dart:async"';
-    String libraryText = 'import $uriString; Future x;';
-    serializeLibraryText(libraryText);
-    // Second import is the implicit import of dart:core
-    expect(unlinkedUnits[0].imports, hasLength(2));
-    expect(unlinkedUnits[0].imports[0].uri, 'dart:async');
-  }
-
-  test_invalid_prefix_dynamic() {
-    if (checkAstDerivedData) {
-      // TODO(paulberry): get this to work properly.
-      return;
-    }
-    checkUnresolvedTypeRef(
-        serializeTypeText('dynamic.T', allowErrors: true), 'dynamic', 'T');
-  }
-
-  test_invalid_prefix_type_parameter() {
-    if (checkAstDerivedData) {
-      // TODO(paulberry): get this to work properly.
-      return;
-    }
-    checkUnresolvedTypeRef(
-        serializeClassText('class C<T> { T.U x; }', allowErrors: true).fields[0]
-            .type,
-        'T',
-        'U');
-  }
-
-  test_invalid_prefix_void() {
-    if (checkAstDerivedData) {
-      // TODO(paulberry): get this to work properly.
-      return;
-    }
-    checkUnresolvedTypeRef(
-        serializeTypeText('void.T', allowErrors: true), 'void', 'T');
-  }
-
-  test_library_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-library foo;''';
-    serializeLibraryText(text);
-    expect(unlinkedUnits[0].libraryDocumentationComment, isNotNull);
-    checkDocumentationComment(
-        unlinkedUnits[0].libraryDocumentationComment, text);
-  }
-
-  test_library_name_with_spaces() {
-    String text = 'library foo . bar ;';
-    serializeLibraryText(text);
-    expect(unlinkedUnits[0].libraryName, 'foo.bar');
-    expect(unlinkedUnits[0].libraryNameOffset, text.indexOf('foo . bar'));
-    expect(unlinkedUnits[0].libraryNameLength, 'foo . bar'.length);
-  }
-
-  test_library_named() {
-    String text = 'library foo.bar;';
-    serializeLibraryText(text);
-    expect(unlinkedUnits[0].libraryName, 'foo.bar');
-    expect(unlinkedUnits[0].libraryNameOffset, text.indexOf('foo.bar'));
-    expect(unlinkedUnits[0].libraryNameLength, 'foo.bar'.length);
-  }
-
-  test_library_unnamed() {
-    serializeLibraryText('');
-    expect(unlinkedUnits[0].libraryName, isEmpty);
-    expect(unlinkedUnits[0].libraryNameOffset, 0);
-    expect(unlinkedUnits[0].libraryNameLength, 0);
-  }
-
-  test_library_with_missing_part() {
-    // References to other parts should still be resolved.
-    allowMissingFiles = true;
-    addNamedSource('/bar.dart', 'part of my.lib; class C {}');
-    serializeLibraryText(
-        'library my.lib; part "foo.dart"; part "bar.dart"; C c;',
-        allowErrors: true);
-    checkTypeRef(findVariable('c').type, null, null, 'C',
-        expectedTargetUnit: 2);
-  }
-
-  test_linked_reference_reuse() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    // When the reference for a linked type is the same as an explicitly
-    // referenced type, the explicit reference should be re-used.
-    addNamedSource('/a.dart', 'class C {}');
-    addNamedSource('/b.dart', 'import "a.dart"; C f() => null;');
-    serializeLibraryText(
-        'import "a.dart"; import "b.dart"; C c1; final c2 = f();');
-    int explicitReference = findVariable('c1').type.reference;
-    expect(getTypeRefForSlot(findVariable('c2').propagatedTypeSlot).reference,
-        explicitReference);
-  }
-
-  test_linked_type_dependency_reuse() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    // When the dependency for a linked type is the same as an explicit
-    // dependency, the explicit dependency should be re-used.
-    addNamedSource('/a.dart', 'class C {} class D {}');
-    addNamedSource('/b.dart', 'import "a.dart"; D f() => null;');
-    serializeLibraryText(
-        'import "a.dart"; import "b.dart"; C c; final d = f();');
-    int cReference = findVariable('c').type.reference;
-    int explicitDependency = linked.units[0].references[cReference].dependency;
-    int dReference =
-        getTypeRefForSlot(findVariable('d').propagatedTypeSlot).reference;
-    expect(
-        linked.units[0].references[dReference].dependency, explicitDependency);
-  }
-
-  test_local_names_take_precedence_over_imported_names() {
-    addNamedSource('/a.dart', 'class C {} class D {}');
-    serializeLibraryText('''
-import 'a.dart';
-class C {}
-C c;
-D d;''');
-    checkTypeRef(findVariable('c').type, null, null, 'C');
-    checkTypeRef(findVariable('d').type, absUri('/a.dart'), 'a.dart', 'D');
-  }
-
-  test_method_documented() {
-    String text = '''
-class C {
-  /**
-   * Docs
-   */
-  f() {}
-}''';
-    UnlinkedExecutable executable = serializeClassText(text).executables[0];
-    expect(executable.documentationComment, isNotNull);
-    checkDocumentationComment(executable.documentationComment, text);
-  }
-
-  test_part_declaration() {
-    addNamedSource('/a.dart', 'part of my.lib;');
-    String text = 'library my.lib; part "a.dart"; // <-part';
-    serializeLibraryText(text);
-    expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.parts[0], 'a.dart');
-    expect(unlinkedUnits[0].parts, hasLength(1));
-    expect(unlinkedUnits[0].parts[0].uriOffset, text.indexOf('"a.dart"'));
-    expect(unlinkedUnits[0].parts[0].uriEnd, text.indexOf('; // <-part'));
-  }
-
-  test_parts_defining_compilation_unit() {
-    serializeLibraryText('');
-    expect(linked.units, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.parts, isEmpty);
-  }
-
-  test_parts_included() {
-    addNamedSource('/part1.dart', 'part of my.lib;');
-    String partString = '"part1.dart"';
-    String libraryText = 'library my.lib; part $partString;';
-    serializeLibraryText(libraryText);
-    expect(linked.units, hasLength(2));
-    expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
-    expect(unlinkedUnits[0].publicNamespace.parts[0], 'part1.dart');
-  }
-
-  test_public_namespace_of_part() {
-    addNamedSource('/a.dart', 'part of foo; class C {}');
-    serializeLibraryText('library foo; part "a.dart";');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-    expect(unlinkedUnits[1].publicNamespace.names, hasLength(1));
-    expect(unlinkedUnits[1].publicNamespace.names[0].name, 'C');
-  }
-
-  test_setter_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-void set f(value) {}''';
-    UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
-    expect(executable.documentationComment, isNotNull);
-    checkDocumentationComment(executable.documentationComment, text);
-  }
-
-  test_slot_reuse() {
-    // Different compilation units have independent notions of slot id, so slot
-    // ids should be reused.
-    addNamedSource('/a.dart', 'part of foo; final v = 0;');
-    serializeLibraryText('library foo; part "a.dart"; final w = 0;');
-    expect(unlinkedUnits[0].variables[0].propagatedTypeSlot, 1);
-    expect(unlinkedUnits[1].variables[0].propagatedTypeSlot, 1);
-  }
-
-  test_type_arguments_explicit() {
-    TypeRef typeRef = serializeTypeText('List<int>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
-    expect(typeRef.typeArguments, hasLength(1));
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
-  }
-
-  test_type_arguments_explicit_dynamic() {
-    TypeRef typeRef = serializeTypeText('List<dynamic>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
-    expect(typeRef.typeArguments, isEmpty);
-  }
-
-  test_type_arguments_explicit_dynamic_dynamic() {
-    TypeRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
-    // Trailing type arguments of type `dynamic` are omitted.
-    expect(typeRef.typeArguments, isEmpty);
-  }
-
-  test_type_arguments_explicit_dynamic_int() {
-    TypeRef typeRef = serializeTypeText('Map<dynamic, int>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
-    // Leading type arguments of type `dynamic` are not omitted.
-    expect(typeRef.typeArguments.length, 2);
-    checkDynamicTypeRef(typeRef.typeArguments[0]);
-    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
-  }
-
-  test_type_arguments_explicit_dynamic_typedef() {
-    TypeRef typeRef =
-        serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
-    checkTypeRef(typeRef, null, null, 'F',
-        allowTypeParameters: true,
-        expectedKind: ReferenceKind.typedef,
-        numTypeParameters: 1);
-    expect(typeRef.typeArguments, isEmpty);
-  }
-
-  test_type_arguments_explicit_String_dynamic() {
-    TypeRef typeRef = serializeTypeText('Map<String, dynamic>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
-    // Trailing type arguments of type `dynamic` are omitted.
-    expect(typeRef.typeArguments.length, 1);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
-  }
-
-  test_type_arguments_explicit_String_int() {
-    TypeRef typeRef = serializeTypeText('Map<String, int>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
-    expect(typeRef.typeArguments.length, 2);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
-    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
-  }
-
-  test_type_arguments_explicit_typedef() {
-    TypeRef typeRef =
-        serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
-    checkTypeRef(typeRef, null, null, 'F',
-        allowTypeParameters: true,
-        expectedKind: ReferenceKind.typedef,
-        numTypeParameters: 1);
-    expect(typeRef.typeArguments, hasLength(1));
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
-  }
-
-  test_type_arguments_implicit() {
-    TypeRef typeRef = serializeTypeText('List');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        allowTypeParameters: true, numTypeParameters: 1);
-    expect(typeRef.typeArguments, isEmpty);
-  }
-
-  test_type_arguments_implicit_typedef() {
-    TypeRef typeRef =
-        serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
-    checkTypeRef(typeRef, null, null, 'F',
-        allowTypeParameters: true,
-        expectedKind: ReferenceKind.typedef,
-        numTypeParameters: 1);
-    expect(typeRef.typeArguments, isEmpty);
-  }
-
-  test_type_arguments_order() {
-    TypeRef typeRef = serializeTypeText('Map<int, Object>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
-    expect(typeRef.typeArguments, hasLength(2));
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
-    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
-  }
-
-  test_type_dynamic() {
-    checkDynamicTypeRef(serializeTypeText('dynamic'));
-  }
-
-  test_type_param_not_shadowed_by_constructor() {
-    UnlinkedClass cls =
-        serializeClassText('class C<D> { D x; C.D(); } class D {}');
-    checkParamTypeRef(cls.fields[0].type, 1);
-  }
-
-  test_type_param_not_shadowed_by_field_in_extends() {
-    UnlinkedClass cls =
-        serializeClassText('class C<T> extends D<T> { T x; } class D<T> {}');
-    checkParamTypeRef(cls.supertype.typeArguments[0], 1);
-  }
-
-  test_type_param_not_shadowed_by_field_in_implements() {
-    UnlinkedClass cls =
-        serializeClassText('class C<T> implements D<T> { T x; } class D<T> {}');
-    checkParamTypeRef(cls.interfaces[0].typeArguments[0], 1);
-  }
-
-  test_type_param_not_shadowed_by_field_in_with() {
-    UnlinkedClass cls = serializeClassText(
-        'class C<T> extends Object with D<T> { T x; } class D<T> {}');
-    checkParamTypeRef(cls.mixins[0].typeArguments[0], 1);
-  }
-
-  test_type_param_not_shadowed_by_method_parameter() {
-    UnlinkedClass cls = serializeClassText('class C<T> { f(int T, T x) {} }');
-    checkParamTypeRef(cls.executables[0].parameters[1].type, 1);
-  }
-
-  test_type_param_not_shadowed_by_setter() {
-    // The code under test should not produce a compile-time error, but it
-    // does.
-    bool workAroundBug25525 = true;
-    UnlinkedClass cls = serializeClassText(
-        'class C<D> { D x; void set D(value) {} } class D {}',
-        allowErrors: workAroundBug25525);
-    checkParamTypeRef(cls.fields[0].type, 1);
-  }
-
-  test_type_param_not_shadowed_by_typedef_parameter() {
-    UnlinkedTypedef typedef =
-        serializeTypedefText('typedef void F<T>(int T, T x);');
-    checkParamTypeRef(typedef.parameters[1].type, 1);
-  }
-
-  test_type_param_shadowed_by_field() {
-    UnlinkedClass cls = serializeClassText(
-        'class C<D> { D x; int D; } class D {}',
-        allowErrors: true);
-    checkDynamicTypeRef(cls.fields[0].type);
-  }
-
-  test_type_param_shadowed_by_getter() {
-    UnlinkedClass cls = serializeClassText(
-        'class C<D> { D x; int get D => null; } class D {}',
-        allowErrors: true);
-    checkDynamicTypeRef(cls.fields[0].type);
-  }
-
-  test_type_param_shadowed_by_method() {
-    UnlinkedClass cls = serializeClassText(
-        'class C<D> { D x; void D() {} } class D {}',
-        allowErrors: true);
-    checkDynamicTypeRef(cls.fields[0].type);
-  }
-
-  test_type_param_shadowed_by_type_param() {
-    UnlinkedClass cls =
-        serializeClassText('class C<T> { T f<T>(T x) => null; }');
-    checkParamTypeRef(cls.executables[0].returnType, 1);
-    checkParamTypeRef(cls.executables[0].parameters[0].type, 1);
-  }
-
-  test_type_reference_from_part() {
-    addNamedSource('/a.dart', 'part of foo; C v;');
-    serializeLibraryText('library foo; part "a.dart"; class C {}');
-    checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
-        null, null, 'C',
-        expectedKind: ReferenceKind.classOrEnum,
-        linkedSourceUnit: linked.units[1],
-        unlinkedSourceUnit: unlinkedUnits[1]);
-  }
-
-  test_type_reference_from_part_withPrefix() {
-    addNamedSource('/a.dart', 'class C {}');
-    addNamedSource('/p.dart', 'part of foo; a.C v;');
-    serializeLibraryText(
-        'library foo; import "a.dart"; import "a.dart" as a; part "p.dart";',
-        allowErrors: true);
-    checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
-        absUri('/a.dart'), 'a.dart', 'C',
-        expectedPrefix: 'a',
-        linkedSourceUnit: linked.units[1],
-        unlinkedSourceUnit: unlinkedUnits[1]);
-  }
-
-  test_type_reference_to_class_argument() {
-    UnlinkedClass cls = serializeClassText('class C<T, U> { T t; U u; }');
-    {
-      TypeRef typeRef =
-          findVariable('t', variables: cls.fields, failIfAbsent: true).type;
-      checkParamTypeRef(typeRef, 2);
-    }
-    {
-      TypeRef typeRef =
-          findVariable('u', variables: cls.fields, failIfAbsent: true).type;
-      checkParamTypeRef(typeRef, 1);
-    }
-  }
-
-  test_type_reference_to_import_of_export() {
-    addNamedSource('/a.dart', 'library a; export "b.dart";');
-    addNamedSource('/b.dart', 'library b; class C {}');
-    checkTypeRef(serializeTypeText('C', otherDeclarations: 'import "a.dart";'),
-        absUri('/b.dart'), 'b.dart', 'C');
-  }
-
-  test_type_reference_to_import_of_export_via_prefix() {
-    addNamedSource('/a.dart', 'library a; export "b.dart";');
-    addNamedSource('/b.dart', 'library b; class C {}');
-    checkTypeRef(
-        serializeTypeText('p.C', otherDeclarations: 'import "a.dart" as p;'),
-        absUri('/b.dart'),
-        'b.dart',
-        'C',
-        expectedPrefix: 'p');
-  }
-
-  test_type_reference_to_imported_part() {
-    addNamedSource('/a.dart', 'library my.lib; part "b.dart";');
-    addNamedSource('/b.dart', 'part of my.lib; class C {}');
-    checkTypeRef(
-        serializeTypeText('C',
-            otherDeclarations: 'library my.lib; import "a.dart";'),
-        absUri('/a.dart'),
-        'a.dart',
-        'C',
-        expectedTargetUnit: 1);
-  }
-
-  test_type_reference_to_imported_part_with_prefix() {
-    addNamedSource('/a.dart', 'library my.lib; part "b.dart";');
-    addNamedSource('/b.dart', 'part of my.lib; class C {}');
-    checkTypeRef(
-        serializeTypeText('p.C',
-            otherDeclarations: 'library my.lib; import "a.dart" as p;'),
-        absUri('/a.dart'),
-        'a.dart',
-        'C',
-        expectedPrefix: 'p',
-        expectedTargetUnit: 1);
-  }
-
-  test_type_reference_to_internal_class() {
-    checkTypeRef(serializeTypeText('C', otherDeclarations: 'class C {}'), null,
-        null, 'C');
-  }
-
-  test_type_reference_to_internal_class_alias() {
-    checkTypeRef(
-        serializeTypeText('C',
-            otherDeclarations: 'class C = D with E; class D {} class E {}'),
-        null,
-        null,
-        'C');
-  }
-
-  test_type_reference_to_internal_enum() {
-    checkTypeRef(serializeTypeText('E', otherDeclarations: 'enum E { value }'),
-        null, null, 'E');
-  }
-
-  test_type_reference_to_local_part() {
-    addNamedSource('/a.dart', 'part of my.lib; class C {}');
-    checkTypeRef(
-        serializeTypeText('C',
-            otherDeclarations: 'library my.lib; part "a.dart";'),
-        null,
-        null,
-        'C',
-        expectedTargetUnit: 1);
-  }
-
-  test_type_reference_to_nonexistent_file_via_prefix() {
-    if (!checkAstDerivedData) {
-      // TODO(paulberry): this test currently fails because there is not enough
-      // information in the element model to figure out that the unresolved
-      // reference `p.C` uses the prefix `p`.
-      return;
-    }
-    allowMissingFiles = true;
-    TypeRef typeRef = serializeTypeText('p.C',
-        otherDeclarations: 'import "foo.dart" as p;', allowErrors: true);
-    checkUnresolvedTypeRef(typeRef, 'p', 'C');
-  }
-
-  test_type_reference_to_part() {
-    addNamedSource('/a.dart', 'part of foo; class C { C(); }');
-    serializeLibraryText('library foo; part "a.dart"; C c;');
-    checkTypeRef(unlinkedUnits[0].variables.single.type, null, null, 'C',
-        expectedKind: ReferenceKind.classOrEnum, expectedTargetUnit: 1);
-  }
-
-  test_type_reference_to_type_visible_via_multiple_import_prefixes() {
-    if (!checkAstDerivedData) {
-      // TODO(paulberry): this test currently fails because the element model
-      // doesn't record enough information to track which prefix is used to
-      // refer to a type.
-      return;
-    }
-    addNamedSource('/lib1.dart', 'class C');
-    addNamedSource('/lib2.dart', 'export "lib1.dart";');
-    addNamedSource('/lib3.dart', 'export "lib1.dart";');
-    addNamedSource('/lib4.dart', 'export "lib1.dart";');
-    serializeLibraryText('''
-import 'lib2.dart';
-import 'lib3.dart' as a;
-import 'lib4.dart' as b;
-C c2;
-a.C c3;
-b.C c4;''');
-    // Note: it is important that each reference to class C records the prefix
-    // used to find it; otherwise it's possible that relinking might produce an
-    // incorrect result after a change to lib2.dart, lib3.dart, or lib4.dart.
-    checkTypeRef(
-        findVariable('c2').type, absUri('/lib1.dart'), 'lib1.dart', 'C');
-    checkTypeRef(
-        findVariable('c3').type, absUri('/lib1.dart'), 'lib1.dart', 'C',
-        expectedPrefix: 'a');
-    checkTypeRef(
-        findVariable('c4').type, absUri('/lib1.dart'), 'lib1.dart', 'C',
-        expectedPrefix: 'b');
-  }
-
-  test_type_reference_to_typedef() {
-    checkTypeRef(serializeTypeText('F', otherDeclarations: 'typedef void F();'),
-        null, null, 'F',
-        expectedKind: ReferenceKind.typedef);
-  }
-
-  test_type_unit_counts_unreferenced_units() {
-    addNamedSource('/a.dart', 'library a; part "b.dart"; part "c.dart";');
-    addNamedSource('/b.dart', 'part of a;');
-    addNamedSource('/c.dart', 'part of a; class C {}');
-    TypeRef typeRef =
-        serializeTypeText('C', otherDeclarations: 'import "a.dart";');
-    // The referenced unit should be 2, since unit 0 is a.dart and unit 1 is
-    // b.dart.  a.dart and b.dart are counted even though nothing is imported
-    // from them.
-    checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C',
-        expectedTargetUnit: 2);
-  }
-
-  test_type_unresolved() {
-    TypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
-    checkUnresolvedTypeRef(typeRef, null, 'Foo');
-  }
-
-  test_typedef_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-typedef F();''';
-    UnlinkedTypedef typedef = serializeTypedefText(text);
-    expect(typedef.documentationComment, isNotNull);
-    checkDocumentationComment(typedef.documentationComment, text);
-  }
-
-  test_typedef_name() {
-    String text = 'typedef F();';
-    UnlinkedTypedef type = serializeTypedefText(text);
-    expect(type.name, 'F');
-    expect(type.nameOffset, text.indexOf('F'));
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
-    expect(
-        unlinkedUnits[0].publicNamespace.names[0].kind, ReferenceKind.typedef);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'F');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
-  }
-
-  test_typedef_param_none() {
-    UnlinkedTypedef type = serializeTypedefText('typedef F();');
-    expect(type.parameters, isEmpty);
-  }
-
-  test_typedef_param_order() {
-    UnlinkedTypedef type = serializeTypedefText('typedef F(x, y);');
-    expect(type.parameters, hasLength(2));
-    expect(type.parameters[0].name, 'x');
-    expect(type.parameters[1].name, 'y');
-  }
-
-  test_typedef_private() {
-    serializeTypedefText('typedef _F();', '_F');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_typedef_reference_generic() {
-    TypeRef typeRef =
-        serializeTypeText('F', otherDeclarations: 'typedef void F<A, B>();');
-    checkTypeRef(typeRef, null, null, 'F',
-        numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
-  }
-
-  test_typedef_reference_generic_imported() {
-    addNamedSource('/lib.dart', 'typedef void F<A, B>();');
-    TypeRef typeRef =
-        serializeTypeText('F', otherDeclarations: 'import "lib.dart";');
-    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'F',
-        numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
-  }
-
-  test_typedef_return_type_explicit() {
-    UnlinkedTypedef type = serializeTypedefText('typedef int F();');
-    checkTypeRef(type.returnType, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_typedef_type_param_in_parameter() {
-    UnlinkedTypedef type = serializeTypedefText('typedef F<T>(T t);');
-    checkParamTypeRef(type.parameters[0].type, 1);
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
-  }
-
-  test_typedef_type_param_in_return_type() {
-    UnlinkedTypedef type = serializeTypedefText('typedef T F<T>();');
-    checkParamTypeRef(type.returnType, 1);
-  }
-
-  test_typedef_type_param_none() {
-    UnlinkedTypedef type = serializeTypedefText('typedef F();');
-    expect(type.typeParameters, isEmpty);
-  }
-
-  test_typedef_type_param_order() {
-    UnlinkedTypedef type = serializeTypedefText('typedef F<T, U>();');
-    expect(type.typeParameters, hasLength(2));
-    expect(type.typeParameters[0].name, 'T');
-    expect(type.typeParameters[1].name, 'U');
-  }
-
-  test_unresolved_reference_in_multiple_parts() {
-    addNamedSource('/a.dart', 'part of foo; int x; Unresolved y;');
-    serializeLibraryText('library foo; part "a.dart"; Unresolved z;',
-        allowErrors: true);
-    // The unresolved types in the defining compilation unit and the part
-    // should both work correctly even though they use different reference
-    // indices.
-    checkUnresolvedTypeRef(
-        unlinkedUnits[0].variables[0].type, null, 'Unresolved');
-    checkUnresolvedTypeRef(
-        unlinkedUnits[1].variables[1].type, null, 'Unresolved',
-        linkedSourceUnit: linked.units[1],
-        unlinkedSourceUnit: unlinkedUnits[1]);
-  }
-
-  test_variable() {
-    String text = 'int i;';
-    UnlinkedVariable v = serializeVariableText(text, variableName: 'i');
-    expect(v.nameOffset, text.indexOf('i;'));
-    expect(findExecutable('i'), isNull);
-    expect(findExecutable('i='), isNull);
-    expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
-    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        ReferenceKind.topLevelPropertyAccessor);
-    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
-    expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
-    expect(unlinkedUnits[0].publicNamespace.names[1].kind,
-        ReferenceKind.topLevelPropertyAccessor);
-    expect(unlinkedUnits[0].publicNamespace.names[1].name, 'i=');
-    expect(unlinkedUnits[0].publicNamespace.names[1].numTypeParameters, 0);
-  }
-
-  test_variable_const() {
-    UnlinkedVariable variable =
-        serializeVariableText('const int i = 0;', variableName: 'i');
-    expect(variable.isConst, isTrue);
-  }
-
-  test_variable_documented() {
-    String text = '''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-var v;''';
-    UnlinkedVariable variable = serializeVariableText(text);
-    expect(variable.documentationComment, isNotNull);
-    checkDocumentationComment(variable.documentationComment, text);
-  }
-
-  test_variable_explicit_dynamic() {
-    UnlinkedVariable variable = serializeVariableText('dynamic v;');
-    checkDynamicTypeRef(variable.type);
-    expect(variable.hasImplicitType, isFalse);
-  }
-
-  test_variable_final_top_level() {
-    UnlinkedVariable variable =
-        serializeVariableText('final int i = 0;', variableName: 'i');
-    expect(variable.isFinal, isTrue);
-  }
-
-  test_variable_implicit_dynamic() {
-    UnlinkedVariable variable = serializeVariableText('var v;');
-    checkDynamicTypeRef(variable.type);
-    expect(variable.hasImplicitType, isTrue);
-  }
-
-  test_variable_name() {
-    UnlinkedVariable variable =
-        serializeVariableText('int i;', variableName: 'i');
-    expect(variable.name, 'i');
-  }
-
-  test_variable_no_flags() {
-    UnlinkedVariable variable =
-        serializeVariableText('int i;', variableName: 'i');
-    expect(variable.isStatic, isFalse);
-    expect(variable.isConst, isFalse);
-    expect(variable.isFinal, isFalse);
-  }
-
-  test_variable_non_const() {
-    UnlinkedVariable variable =
-        serializeVariableText('int i = 0;', variableName: 'i');
-    expect(variable.isConst, isFalse);
-  }
-
-  test_variable_non_final() {
-    UnlinkedVariable variable =
-        serializeVariableText('int i;', variableName: 'i');
-    expect(variable.isFinal, isFalse);
-  }
-
-  test_variable_non_static() {
-    UnlinkedVariable variable =
-        serializeClassText('class C { int i; }').fields[0];
-    expect(variable.isStatic, isFalse);
-  }
-
-  test_variable_non_static_top_level() {
-    // Top level variables are considered non-static.
-    UnlinkedVariable variable =
-        serializeVariableText('int i;', variableName: 'i');
-    expect(variable.isStatic, isFalse);
-  }
-
-  test_variable_private() {
-    serializeVariableText('int _i;', variableName: '_i');
-    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
-  }
-
-  test_variable_propagated_type_final_immediate() {
-    UnlinkedVariable v = serializeVariableText('final v = 0;');
-    checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_variable_propagated_type_new_reference() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    UnlinkedVariable v = serializeVariableText('final v = 0;');
-    // Since the propagated type of `v` is `int`, and there are no references
-    // to `int` elsewhere in the source file, a new linked reference should
-    // have been created for it, with no associated unlinked reference.
-    expect(v.propagatedTypeSlot, isNot(0));
-    TypeRef type = getTypeRefForSlot(v.propagatedTypeSlot);
-    expect(type, isNotNull);
-    expect(type.reference,
-        greaterThanOrEqualTo(unlinkedUnits[0].references.length));
-  }
-
-  test_variable_propagated_type_omit_dynamic() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    UnlinkedVariable v = serializeVariableText('final v = <int, dynamic>{};');
-    TypeRef type = getTypeRefForSlot(v.propagatedTypeSlot);
-    checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        allowTypeParameters: true, numTypeParameters: 2);
-    expect(type.typeArguments, hasLength(1));
-    checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
-  }
-
-  test_variable_propagatedTypeSlot_const() {
-    // Const variables are propagable so they have a nonzero
-    // propagatedTypeSlot.
-    UnlinkedVariable variable = serializeVariableText('const v = 0;');
-    expect(variable.propagatedTypeSlot, isNot(0));
-  }
-
-  test_variable_propagatedTypeSlot_final() {
-    // Final variables are propagable so they have a nonzero
-    // propagatedTypeSlot.
-    UnlinkedVariable variable = serializeVariableText('final v = 0;');
-    expect(variable.propagatedTypeSlot, isNot(0));
-  }
-
-  test_variable_propagatedTypeSlot_non_propagable() {
-    // Non-final non-const variables aren't propagable so they don't have a
-    // propagatedTypeSlot.
-    UnlinkedVariable variable = serializeVariableText('var v;');
-    expect(variable.propagatedTypeSlot, 0);
-  }
-
-  test_variable_static() {
-    UnlinkedVariable variable =
-        serializeClassText('class C { static int i; }').fields[0];
-    expect(variable.isStatic, isTrue);
-  }
-
-  test_variable_type() {
-    UnlinkedVariable variable =
-        serializeVariableText('int i;', variableName: 'i');
-    checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
-  }
-
-  void _assertUnlinkedConst(UnlinkedConst constExpr,
-      {List<UnlinkedConstOperation> operators,
-      List<int> ints: const <int>[],
-      List<double> doubles: const <double>[],
-      List<String> strings: const <String>[],
-      List<_TypeRefValidator> referenceValidators:
-          const <_TypeRefValidator>[]}) {
-    expect(constExpr, isNotNull);
-    expect(constExpr.operations, operators);
-    expect(constExpr.ints, ints);
-    expect(constExpr.doubles, doubles);
-    expect(constExpr.strings, strings);
-    expect(constExpr.references, hasLength(referenceValidators.length));
-    for (int i = 0; i < referenceValidators.length; i++) {
-      referenceValidators[i](constExpr.references[i]);
-    }
-  }
-}
-
-/**
- * Override of [SummaryTest] which creates unlinked summaries directly from the
- * AST.
- */
-@reflectiveTest
-class UnlinkedSummarizeAstTest extends Object with SummaryTest {
-  @override
-  LinkedLibrary linked;
-
-  @override
-  List<UnlinkedUnit> unlinkedUnits;
-
-  /**
-   * Map from absolute URI to the [UnlinkedUnit] for each compilation unit
-   * passed to [addNamedSource].
-   */
-  Map<String, UnlinkedUnit> uriToUnit = <String, UnlinkedUnit>{};
-
-  @override
-  bool get checkAstDerivedData => true;
-
-  @override
-  bool get expectAbsoluteUrisInDependencies => false;
-
-  @override
-  bool get skipFullyLinkedData => true;
-
-  @override
-  addNamedSource(String filePath, String contents) {
-    CompilationUnit unit = _parseText(contents);
-    UnlinkedUnit unlinkedUnit =
-        new UnlinkedUnit.fromBuffer(serializeAstUnlinked(unit).toBuffer());
-    uriToUnit[absUri(filePath)] = unlinkedUnit;
-  }
-
-  @override
-  void serializeLibraryText(String text, {bool allowErrors: false}) {
-    Uri testDartUri = Uri.parse(absUri('/test.dart'));
-    String resolveToAbsoluteUri(String relativeUri) =>
-        testDartUri.resolve(relativeUri).toString();
-    CompilationUnit unit = _parseText(text);
-    UnlinkedUnit definingUnit =
-        new UnlinkedUnit.fromBuffer(serializeAstUnlinked(unit).toBuffer());
-    UnlinkedUnit getPart(String relativeUri) {
-      String absoluteUri = resolveToAbsoluteUri(relativeUri);
-      UnlinkedUnit unit = uriToUnit[absoluteUri];
-      if (unit == null && !allowMissingFiles) {
-        fail('Prelinker unexpectedly requested unit for "$relativeUri"'
-            ' (resolves to "$absoluteUri").');
-      }
-      return unit;
-    }
-    UnlinkedPublicNamespace getImport(String relativeUri) {
-      String absoluteUri = resolveToAbsoluteUri(relativeUri);
-      UnlinkedPublicNamespace namespace = sdkPublicNamespace[absoluteUri];
-      if (namespace == null) {
-        namespace = uriToUnit[absoluteUri]?.publicNamespace;
-      }
-      if (namespace == null && !allowMissingFiles) {
-        fail('Prelinker unexpectedly requested namespace for "$relativeUri"'
-            ' (resolves to "$absoluteUri").'
-            '  Namespaces available: ${uriToUnit.keys}');
-      }
-      return namespace;
-    }
-    linked = new LinkedLibrary.fromBuffer(
-        prelink(definingUnit, getPart, getImport).toBuffer());
-    unlinkedUnits = <UnlinkedUnit>[definingUnit];
-    for (String relativeUri in definingUnit.publicNamespace.parts) {
-      UnlinkedUnit unit = uriToUnit[resolveToAbsoluteUri(relativeUri)];
-      if (unit == null) {
-        if (!allowMissingFiles) {
-          fail('Test referred to unknown unit $relativeUri');
-        }
-      } else {
-        unlinkedUnits.add(unit);
-      }
-    }
-  }
-
-  CompilationUnit _parseText(String text) {
-    CharSequenceReader reader = new CharSequenceReader(text);
-    Scanner scanner =
-        new Scanner(null, reader, AnalysisErrorListener.NULL_LISTENER);
-    Token token = scanner.tokenize();
-    Parser parser = new Parser(null, AnalysisErrorListener.NULL_LISTENER);
-    parser.parseGenericMethods = true;
-    return parser.parseCompilationUnit(token);
-  }
-}