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

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 122 matching lines @@
   final Set<LibraryElement> librariesAddedToTransitiveExportClosure =
       new Set<LibraryElement>();
 
   /**
    * Map from imported element to the prefix which may be used to refer to that
    * element; elements for which no prefix is needed are absent from this map.
    */
   final Map<Element, PrefixElement> prefixMap = <Element, PrefixElement>{};
 
   _LibrarySerializer(this.libraryElement, this.typeProvider) {
-    dependencies.add(encodePrelinkedDependency());
+    dependencies.add(new PrelinkedDependencyBuilder());
     dependencyMap[libraryElement] = 0;
   }
 
   /**
    * Retrieve the library element for `dart:core`.
    */
   LibraryElement get coreLibrary => typeProvider.objectType.element.library;
 
   /**
    * Add all classes, enums, typedefs, executables, and top level variables
    * from the given compilation unit [element] to the library summary.
    * [unitNum] indicates the ordinal position of this compilation unit in the
    * library.
    */
   void addCompilationUnitElements(CompilationUnitElement element, int unitNum) {
     UnlinkedUnitBuilder b = new UnlinkedUnitBuilder();
     referenceMap.clear();
-    unlinkedReferences = <UnlinkedReferenceBuilder>[encodeUnlinkedReference()];
+    unlinkedReferences = <UnlinkedReferenceBuilder>[
+      new UnlinkedReferenceBuilder()
+    ];
     prelinkedReferences = <PrelinkedReferenceBuilder>[
-      encodePrelinkedReference(kind: PrelinkedReferenceKind.classOrEnum)
+      new PrelinkedReferenceBuilder(kind: PrelinkedReferenceKind.classOrEnum)
     ];
     List<UnlinkedPublicNameBuilder> names = <UnlinkedPublicNameBuilder>[];
     for (PropertyAccessorElement accessor in element.accessors) {
       if (accessor.isPublic) {
-        names.add(encodeUnlinkedPublicName(
+        names.add(new UnlinkedPublicNameBuilder(
             kind: PrelinkedReferenceKind.topLevelPropertyAccessor,
             name: accessor.name,
             numTypeParameters: accessor.typeParameters.length));
       }
     }
     for (ClassElement cls in element.types) {
       if (cls.isPublic) {
-        names.add(encodeUnlinkedPublicName(
+        names.add(new UnlinkedPublicNameBuilder(
             kind: PrelinkedReferenceKind.classOrEnum,
             name: cls.name,
             numTypeParameters: cls.typeParameters.length));
       }
     }
     for (ClassElement enm in element.enums) {
       if (enm.isPublic) {
-        names.add(encodeUnlinkedPublicName(
+        names.add(new UnlinkedPublicNameBuilder(
             kind: PrelinkedReferenceKind.classOrEnum, name: enm.name));
       }
     }
     for (FunctionElement function in element.functions) {
       if (function.isPublic) {
-        names.add(encodeUnlinkedPublicName(
+        names.add(new UnlinkedPublicNameBuilder(
             kind: PrelinkedReferenceKind.topLevelFunction,
             name: function.name,
             numTypeParameters: function.typeParameters.length));
       }
     }
     for (FunctionTypeAliasElement typedef in element.functionTypeAliases) {
       if (typedef.isPublic) {
-        names.add(encodeUnlinkedPublicName(
+        names.add(new UnlinkedPublicNameBuilder(
             kind: PrelinkedReferenceKind.typedef,
             name: typedef.name,
             numTypeParameters: typedef.typeParameters.length));
       }
     }
     if (unitNum == 0) {
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
         b.libraryNameOffset = libraryElement.nameOffset;
         b.libraryNameLength = libraryElement.nameLength;
         b.libraryDocumentationComment = serializeDocumentation(libraryElement);
       }
-      b.publicNamespace = encodeUnlinkedPublicNamespace(
+      b.publicNamespace = new UnlinkedPublicNamespaceBuilder(
           exports: libraryElement.exports.map(serializeExportPublic).toList(),
           parts: libraryElement.parts
               .map((CompilationUnitElement e) => e.uri)
               .toList(),
           names: names);
       b.exports = libraryElement.exports.map(serializeExportNonPublic).toList();
       b.imports = libraryElement.imports.map(serializeImport).toList();
       b.parts = libraryElement.parts
           .map((CompilationUnitElement e) =>
-              encodeUnlinkedPart(uriOffset: e.uriOffset, uriEnd: e.uriEnd))
+              new UnlinkedPartBuilder(uriOffset: e.uriOffset, uriEnd: e.uriEnd))
           .toList();
     } else {
       // TODO(paulberry): we need to figure out a way to record library, part,
       // import, and export declarations that appear in non-defining
       // compilation units (even though such declarations are prohibited by the
       // language), so that if the user makes code changes that cause a
       // non-defining compilation unit to become a defining compilation unit,
       // we can create a correct summary by simply re-linking.
-      b.publicNamespace = encodeUnlinkedPublicNamespace(names: names);
+      b.publicNamespace = new UnlinkedPublicNamespaceBuilder(names: names);
     }
     b.classes = element.types.map(serializeClass).toList();
     b.enums = element.enums.map(serializeEnum).toList();
     b.typedefs = element.functionTypeAliases.map(serializeTypedef).toList();
     List<UnlinkedExecutableBuilder> executables =
         element.functions.map(serializeExecutable).toList();
     for (PropertyAccessorElement accessor in element.accessors) {
       if (!accessor.isSynthetic) {
         executables.add(serializeExecutable(accessor));
       }
     }
     b.executables = executables;
     List<UnlinkedVariableBuilder> variables = <UnlinkedVariableBuilder>[];
     for (PropertyAccessorElement accessor in element.accessors) {
       if (accessor.isSynthetic && accessor.isGetter) {
         PropertyInducingElement variable = accessor.variable;
         if (variable != null) {
           assert(!variable.isSynthetic);
           variables.add(serializeVariable(variable));
         }
       }
     }
     b.variables = variables;
     b.references = unlinkedReferences;
     unlinkedUnits.add(b);
-    prelinkedUnits.add(encodePrelinkedUnit(references: prelinkedReferences));
+    prelinkedUnits
+        .add(new PrelinkedUnitBuilder(references: prelinkedReferences));
     unitUris.add(element.source.uri.toString());
     unlinkedReferences = null;
     prelinkedReferences = null;
   }
 
   /**
    * Add [exportedLibrary] (and the transitive closure of all libraries it
    * exports) to the dependency table ([PrelinkedLibrary.dependencies]).
    */
   void addTransitiveExportClosure(LibraryElement exportedLibrary) {
@@ skipping 119 matching lines @@
    * Return the index of the entry in the dependency table
    * ([PrelinkedLibrary.dependencies]) for the given [dependentLibrary].  A new
    * entry is added to the table if necessary to satisfy the request.
    */
   int serializeDependency(LibraryElement dependentLibrary) {
     return dependencyMap.putIfAbsent(dependentLibrary, () {
       int index = dependencies.length;
       List<String> parts = dependentLibrary.parts
           .map((CompilationUnitElement e) => e.source.uri.toString())
           .toList();
-      dependencies.add(encodePrelinkedDependency(
+      dependencies.add(new PrelinkedDependencyBuilder(
           uri: dependentLibrary.source.uri.toString(), parts: parts));
       return index;
     });
   }
 
   /**
    * Serialize documentation from the given [element], creating an
    * [UnlinkedDocumentationComment].
    *
    * If [element] has no documentation, `null` is returned.
    */
   UnlinkedDocumentationCommentBuilder serializeDocumentation(Element element) {
     if (element.documentationComment == null) {
       return null;
     }
-    return encodeUnlinkedDocumentationComment(
+    return new UnlinkedDocumentationCommentBuilder(
         text: element.documentationComment,
         offset: element.docRange.offset,
         length: element.docRange.length);
   }
 
   /**
    * Return the index of the entry in the references table
    * ([UnlinkedLibrary.references] and [PrelinkedLibrary.references])
    * representing the pseudo-type `dynamic`.
    */
   int serializeDynamicReference() => 0;
 
   /**
    * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
   UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
     b.name = enumElement.name;
     b.nameOffset = enumElement.nameOffset;
     List<UnlinkedEnumValueBuilder> values = <UnlinkedEnumValueBuilder>[];
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
-        values.add(encodeUnlinkedEnumValue(
+        values.add(new UnlinkedEnumValueBuilder(
             name: field.name,
             nameOffset: field.nameOffset,
             documentationComment: serializeDocumentation(field)));
       }
     }
     b.values = values;
     b.documentationComment = serializeDocumentation(enumElement);
     return b;
   }
 
@@ skipping 122 matching lines @@
         kind = PrelinkedReferenceKind.topLevelPropertyAccessor;
       } else if (element is FunctionTypeAliasElement) {
         kind = PrelinkedReferenceKind.typedef;
       } else if (element is ClassElement) {
         kind = PrelinkedReferenceKind.classOrEnum;
       } else if (element is FunctionElement) {
         kind = PrelinkedReferenceKind.topLevelFunction;
       } else {
         throw new Exception('Unexpected element kind: ${element.runtimeType}');
       }
-      exportNames.add(encodePrelinkedExportName(
+      exportNames.add(new PrelinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 
   /**
@@ skipping 33 matching lines @@
     return b;
   }
 
   /**
    * Serialize the given [prefix] into an index into the references table.
    */
   int serializePrefix(PrefixElement element) {
     return referenceMap.putIfAbsent(element, () {
       assert(unlinkedReferences.length == prelinkedReferences.length);
       int index = unlinkedReferences.length;
-      unlinkedReferences.add(encodeUnlinkedReference(name: element.name));
-      prelinkedReferences
-          .add(encodePrelinkedReference(kind: PrelinkedReferenceKind.prefix));
+      unlinkedReferences.add(new UnlinkedReferenceBuilder(name: element.name));
+      prelinkedReferences.add(
+          new PrelinkedReferenceBuilder(kind: PrelinkedReferenceKind.prefix));
       return index;
     });
   }
 
   /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
@@ skipping 56 matching lines @@
           // TODO(paulberry): to avoid subtle relinking inconsistencies we
           // should use the actual prefix from the AST (a given type may be
           // reachable via multiple prefixes), but sadly, this information is
           // not recorded in the element model.
           int prefixReference = 0;
           PrefixElement prefix = prefixMap[element];
           if (prefix != null) {
             prefixReference = serializePrefix(prefix);
           }
           int index = unlinkedReferences.length;
-          unlinkedReferences.add(encodeUnlinkedReference(
+          unlinkedReferences.add(new UnlinkedReferenceBuilder(
               name: element.name, prefixReference: prefixReference));
-          prelinkedReferences.add(encodePrelinkedReference(
+          prelinkedReferences.add(new PrelinkedReferenceBuilder(
               dependency: serializeDependency(dependentLibrary),
               kind: element is FunctionTypeAliasElement
                   ? PrelinkedReferenceKind.typedef
                   : PrelinkedReferenceKind.classOrEnum,
               unit: unit,
               numTypeParameters: numTypeParameters));
           return index;
         });
       }
       List<DartType> typeArguments;
@@ skipping 19 matching lines @@
    * satisfy the request.
    */
   int serializeUnresolvedReference() {
     // TODO(paulberry): in order for relinking to work, we need to record the
     // name and prefix of the unresolved symbol.  This is not (yet) encoded in
     // the element model.  For the moment we use a name that can't possibly
     // ever exist.
     if (unresolvedReferenceIndex == null) {
       assert(unlinkedReferences.length == prelinkedReferences.length);
       unresolvedReferenceIndex = unlinkedReferences.length;
-      unlinkedReferences.add(encodeUnlinkedReference(name: '*unresolved*'));
-      prelinkedReferences.add(
-          encodePrelinkedReference(kind: PrelinkedReferenceKind.unresolved));
+      unlinkedReferences
+          .add(new UnlinkedReferenceBuilder(name: '*unresolved*'));
+      prelinkedReferences.add(new PrelinkedReferenceBuilder(
+          kind: PrelinkedReferenceKind.unresolved));
     }
     return unresolvedReferenceIndex;
   }
 
   /**
    * Serialize the given [variable], creating an [UnlinkedVariable].
    */
   UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
     b.name = variable.name;
     b.nameOffset = variable.nameOffset;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     b.documentationComment = serializeDocumentation(variable);
     return b;
   }
 }