Refactor code that populates the references table.

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/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 413 matching lines @@
       for (MethodElement method in cls.methods) {
         if (method.isStatic && method.isPublic) {
           // TODO(paulberry): should numTypeParameters include class params?
           bs.add(new UnlinkedPublicNameBuilder(
               name: method.name,
               kind: ReferenceKind.method,
               numTypeParameters: method.typeParameters.length));
         }
       }
       for (ConstructorElement constructor in cls.constructors) {
-        if (constructor.isPublic &&
-            constructor.name.isNotEmpty) {
+        if (constructor.isPublic && constructor.name.isNotEmpty) {
           // TODO(paulberry): should numTypeParameters include class params?
           bs.add(new UnlinkedPublicNameBuilder(
               name: constructor.name,
               kind: ReferenceKind.constructor,
               numTypeParameters: 0));
         }
       }
       return bs;
     }
     return null;
@@ skipping 214 matching lines @@
         b.defaultValue = serializeConstExpr(initializer);
       }
     }
     return b;
   }
 
   /**
    * Serialize the given [prefix] into an index into the references table.
    */
   int serializePrefix(PrefixElement element) {
-    return referenceMap.putIfAbsent(element, () {
-      assert(unlinkedReferences.length == linkedReferences.length);
-      int index = unlinkedReferences.length;
-      unlinkedReferences.add(new UnlinkedReferenceBuilder(name: element.name));
-      linkedReferences
-          .add(new LinkedReferenceBuilder(kind: ReferenceKind.prefix));
-      return index;
-    });
+    return referenceMap.putIfAbsent(element,
+        () => serializeUnlinkedReference(element.name, ReferenceKind.prefix));
   }
 
   /**
    * Compute the reference index which should be stored in a [EntityRef].
    *
    * If [linked] is true, and a new reference has to be created, the reference
    * will only be stored in [linkedReferences].
    */
   int serializeReferenceForType(DartType type, bool linked) {
     Element element = type.element;
@@ skipping 101 matching lines @@
                 serializeTypeRef(typeArguments[i], context, linked: linked));
           }
           b.typeArguments = serializedArguments;
         }
       }
     }
     return b;
   }
 
   /**
+   * Create a new entry in the references table ([UnlinkedLibrary.references]
+   * and [LinkedLibrary.references]) representing an entity having the given
+   * [name] and [kind].  If [unit] is given, it is the index of the compilation
+   * unit containing the entity being referred to.  If [prefixReference] is
+   * given, it indicates the entry in the references table for the prefix.
+   */
+  int serializeUnlinkedReference(String name, ReferenceKind kind,
+      {int unit: 0, int prefixReference: 0}) {
+    assert(unlinkedReferences.length == linkedReferences.length);
+    int index = unlinkedReferences.length;
+    unlinkedReferences.add(new UnlinkedReferenceBuilder(
+        name: name, prefixReference: prefixReference));
+    linkedReferences.add(new LinkedReferenceBuilder(kind: kind, unit: unit));
+    return index;
+  }
+
+  /**
    * Return the index of the entry in the references table
    * ([UnlinkedLibrary.references] and [LinkedLibrary.references]) used for
    * unresolved references.  A new entry is added to the table if necessary to
    * 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 == linkedReferences.length);
-      unresolvedReferenceIndex = unlinkedReferences.length;
-      unlinkedReferences
-          .add(new UnlinkedReferenceBuilder(name: '*unresolved*'));
-      linkedReferences
-          .add(new LinkedReferenceBuilder(kind: ReferenceKind.unresolved));
+      return serializeUnlinkedReference(
+          '*unresolved*', ReferenceKind.unresolved);
     }
     return unresolvedReferenceIndex;
   }
 
   /**
    * Serialize the given [variable], creating an [UnlinkedVariable].
    */
   UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
     b.name = variable.name;
@@ skipping 70 matching lines @@
       int unit;
       if (dependentLibrary == null) {
         unit = 0;
         dependentLibrary = librarySerializer.libraryElement;
       } else {
         CompilationUnitElement unitElement =
             element.getAncestor((Element e) => e is CompilationUnitElement);
         unit = dependentLibrary.units.indexOf(unitElement);
         assert(unit != -1);
       }
-      LinkedReferenceBuilder linkedReference = new LinkedReferenceBuilder(
-          dependency: librarySerializer.serializeDependency(dependentLibrary),
-          kind: _getReferenceKind(element),
-          unit: unit);
-      if (element is TypeParameterizedElement) {
-        linkedReference.numTypeParameters = element.typeParameters.length;
-      }
+      ReferenceKind kind = _getReferenceKind(element);
       String name = element == null ? 'void' : element.name;
+      int index;
+      LinkedReferenceBuilder linkedReference;
       if (linked) {
-        linkedReference.name = name;
+        linkedReference =
+            new LinkedReferenceBuilder(kind: kind, unit: unit, name: name);
         Element enclosing = element?.enclosingElement;
         if (enclosing is ClassElement) {
           linkedReference.containingReference =
               _getElementReferenceId(enclosing, linked: linked);
-          linkedReference.numTypeParameters += enclosing.typeParameters.length;
+          linkedReference.numTypeParameters = enclosing.typeParameters.length;
         }
+        index = linkedReferences.length;
+        linkedReferences.add(linkedReference);
       } else {
         assert(unlinkedReferences.length == linkedReferences.length);
         int prefixReference = 0;
         Element enclosing = element?.enclosingElement;
         if (enclosing == null || enclosing is CompilationUnitElement) {
           // Figure out a prefix that may be used to refer to the given element.
           // 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.
           PrefixElement prefix = librarySerializer.prefixMap[element];
           if (prefix != null) {
             prefixReference = serializePrefix(prefix);
           }
         } else {
           prefixReference = _getElementReferenceId(enclosing, linked: linked);
         }
-        unlinkedReferences.add(new UnlinkedReferenceBuilder(
-            name: name, prefixReference: prefixReference));
+        index = serializeUnlinkedReference(name, kind,
+            prefixReference: prefixReference, unit: unit);
+        linkedReference = linkedReferences[index];
       }
-      int index = linkedReferences.length;
-      linkedReferences.add(linkedReference);
+      linkedReference.dependency =
+          librarySerializer.serializeDependency(dependentLibrary);
+      if (element is TypeParameterizedElement) {
+        linkedReference.numTypeParameters += element.typeParameters.length;
+      }
       return index;
     });
   }
 
   int _getLengthPropertyReference(int prefix) {
-    assert(unlinkedReferences.length == linkedReferences.length);
-    int index = linkedReferences.length;
-    unlinkedReferences.add(
-        new UnlinkedReferenceBuilder(name: 'length', prefixReference: prefix));
-    LinkedReferenceBuilder linkedReference =
-        new LinkedReferenceBuilder(kind: ReferenceKind.length);
-    linkedReferences.add(linkedReference);
-    return index;
+    return serializeUnlinkedReference('length', ReferenceKind.length,
+        prefixReference: prefix);
   }
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _CompilationUnitSerializer serializer;
 
@@ skipping 36 matching lines @@
     }
   }
 
   @override
   EntityRefBuilder serializeConstructorName(
       TypeName type, SimpleIdentifier name) {
     EntityRefBuilder typeRef = serializer.serializeTypeRef(type.type, null);
     if (name == null) {
       return typeRef;
     } else {
-      int typeId = typeRef.reference;
-      LinkedReference typeLinkedRef = serializer.linkedReferences[typeId];
-      serializer.unlinkedReferences.add(new UnlinkedReferenceBuilder(
-          name: name.name, prefixReference: typeId));
-      int refId = serializer.linkedReferences.length;
-      serializer.linkedReferences.add(new LinkedReferenceBuilder(
-          kind: ReferenceKind.constructor, unit: typeLinkedRef.unit));
+      LinkedReference typeLinkedRef =
+          serializer.linkedReferences[typeRef.reference];
+      int refId = serializer.serializeUnlinkedReference(
+          name.name, ReferenceKind.constructor,
+          prefixReference: typeRef.reference, unit: typeLinkedRef.unit);
       return new EntityRefBuilder(
           reference: refId, typeArguments: typeRef.typeArguments);
     }
   }
 
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     Element element = identifier.staticElement;
     assert(element != null);
     // The only supported instance property accessor - `length`.
     if (identifier is PrefixedIdentifier &&
@@ skipping 223 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }