Use constructor args in favor of summary "encode" functions.

pkg/analyzer/lib/src/summary/prelink.dart

 // Copyright (c) 2016, 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.
 
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Create a [PrelinkedLibraryBuilder] corresponding to the given
  * [definingUnit], which should be the defining compilation unit for a library.
@@ skipping 55 matching lines @@
    * it accepts.  Otherwise zero.
    */
   final int numTypeParameters;
 
   _Meaning(this.unit, this.kind, this.dependency, this.numTypeParameters);
 
   /**
  * Encode this [_Meaning] as a [PrelinkedExportName], using the given [name].
  */
   PrelinkedExportName encodeExportName(String name) {
-    return encodePrelinkedExportName(
+    return new PrelinkedExportNameBuilder(
         name: name, dependency: dependency, unit: unit, kind: kind);
   }
 
 /**
    * Encode this [_Meaning] as a [PrelinkedReference].
    */
   PrelinkedReferenceBuilder encodeReference() {
-    return encodePrelinkedReference(
+    return new PrelinkedReferenceBuilder(
         unit: unit,
         kind: kind,
         dependency: dependency,
         numTypeParameters: numTypeParameters);
   }
 }
 
 /**
  * A [_Meaning] representing a prefix introduced by an import directive.
  */
@@ skipping 31 matching lines @@
    */
   final Map<String, _Meaning> privateNamespace = <String, _Meaning>{
     '': new _Meaning(0, PrelinkedReferenceKind.classOrEnum, 0, 0)
   };
 
   /**
    * List of dependencies of the library being prelinked.  This will be output
    * to [PrelinkedLibrary.dependencies].
    */
   final List<PrelinkedDependencyBuilder> dependencies =
-      <PrelinkedDependencyBuilder>[encodePrelinkedDependency()];
+      <PrelinkedDependencyBuilder>[new PrelinkedDependencyBuilder()];
 
   /**
    * Map from the relative URI of a dependent library to the index of the
    * corresponding entry in [dependencies].
    */
   final Map<String, int> uriToDependency = <String, int>{null: 0};
 
   /**
    * List of public namespaces corresponding to each entry in [dependencies].
    */
@@ skipping 12 matching lines @@
    */
   Map<String, _Meaning> aggregatePublicNamespace(String relativeUri) {
     if (uriToDependency.containsKey(relativeUri)) {
       return dependencyToPublicNamespace[uriToDependency[relativeUri]];
     }
     assert(dependencies.length == dependencyToPublicNamespace.length);
     int dependency = dependencies.length;
     uriToDependency[relativeUri] = dependency;
     List<String> unitUris = getUnitUris(relativeUri);
     PrelinkedDependencyBuilder prelinkedDependency =
-        encodePrelinkedDependency(uri: relativeUri, parts: unitUris.sublist(1));
+        new PrelinkedDependencyBuilder(
+            uri: relativeUri, parts: unitUris.sublist(1));
     dependencies.add(prelinkedDependency);
 
     Map<String, _Meaning> aggregated = <String, _Meaning>{};
 
     for (int unitNum = 0; unitNum < unitUris.length; unitNum++) {
       String unitUri = unitUris[unitNum];
       UnlinkedPublicNamespace importedNamespace = getImportCached(unitUri);
       if (importedNamespace == null) {
         continue;
       }
@@ skipping 170 matching lines @@
     filterExportNamespace(uri, import.combinators, targetNamespace);
     return uriToDependency[uri];
   }
 
   /**
    * Produce a [PrelinkedUnit] for the given [unit], by resolving every one of
    * its references.
    */
   PrelinkedUnitBuilder linkUnit(UnlinkedUnit unit) {
     if (unit == null) {
-      return encodePrelinkedUnit();
+      return new PrelinkedUnitBuilder();
     }
     Map<int, Map<String, _Meaning>> prefixNamespaces =
         <int, Map<String, _Meaning>>{};
     List<PrelinkedReferenceBuilder> references = <PrelinkedReferenceBuilder>[];
     for (int i = 0; i < unit.references.length; i++) {
       UnlinkedReference reference = unit.references[i];
       Map<String, _Meaning> namespace;
       if (reference.prefixReference != 0) {
         // Prefix references must always point backward.
         assert(reference.prefixReference < i);
         namespace = prefixNamespaces[reference.prefixReference];
         // Prefix references must always point to proper prefixes.
         assert(namespace != null);
       } else {
         namespace = privateNamespace;
       }
       _Meaning meaning = namespace[reference.name];
       if (meaning != null) {
         if (meaning is _PrefixMeaning) {
           prefixNamespaces[i] = meaning.namespace;
         }
         references.add(meaning.encodeReference());
       } else {
-        references.add(
-            encodePrelinkedReference(kind: PrelinkedReferenceKind.unresolved));
+        references.add(new PrelinkedReferenceBuilder(
+            kind: PrelinkedReferenceKind.unresolved));
       }
     }
-    return encodePrelinkedUnit(references: references);
+    return new PrelinkedUnitBuilder(references: references);
   }
 
   /**
    * Form the [PrelinkedLibrary] for the [definingUnit] that was passed to the
    * constructor.
    */
   PrelinkedLibraryBuilder prelink() {
     // Gather up the unlinked summaries for all the compilation units in the
     // library.
     List<UnlinkedUnit> units = getUnitUris(null).map(getPartCached).toList();
@@ skipping 27 matching lines @@
       }
     }
 
     // Fill in imported names.
     List<int> importDependencies =
         definingUnit.imports.map(handleImport).toList();
 
     // Link each compilation unit.
     List<PrelinkedUnitBuilder> linkedUnits = units.map(linkUnit).toList();
 
-    return encodePrelinkedLibrary(
+    return new PrelinkedLibraryBuilder(
         units: linkedUnits,
         dependencies: dependencies,
         importDependencies: importDependencies,
         exportNames: exportNames);
   }
 
   /**
    * Resolve [relativeUri] relative to [sourceUri].  Works correctly if
    * [sourceUri] is also relative.
    */
   String resolveUri(String sourceUri, String relativeUri) {
     if (sourceUri == null) {
       return relativeUri;
     } else {
       return Uri.parse(sourceUri).resolve(relativeUri).toString();
     }
   }
 }