Refactor _LibraryResynthesizer.getReferencedLocation.

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 374 matching lines @@
           _push(
               AstFactory.conditionalExpression(condition, thenExpr, elseExpr));
           break;
         // identical
         case UnlinkedConstOperation.identical:
           Expression second = _pop();
           Expression first = _pop();
           _push(AstFactory.methodInvocation(
               null, 'identical', <Expression>[first, second]));
           break;
-      // TODO(scheglov) complete implementation
+        // TODO(scheglov) complete implementation
         case UnlinkedConstOperation.makeUntypedList:
         case UnlinkedConstOperation.makeTypedList:
         case UnlinkedConstOperation.makeUntypedMap:
         case UnlinkedConstOperation.makeTypedMap:
         case UnlinkedConstOperation.pushReference:
         case UnlinkedConstOperation.invokeConstructor:
         case UnlinkedConstOperation.length:
           return AstFactory.nullLiteral();
 //          throw new StateError('Unsupported constant operation $operation');
       }
@@ skipping 457 matching lines @@
   /**
    * Build an [ElementHandle] referring to the entity referred to by the given
    * [exportName].
    */
   ElementHandle buildExportName(LinkedExportName exportName) {
     String name = exportName.name;
     if (exportName.kind == ReferenceKind.topLevelPropertyAccessor &&
         !name.endsWith('=')) {
       name += '?';
     }
-    ElementLocationImpl location = getReferencedLocation(
-        linkedLibrary.dependencies[exportName.dependency],
-        exportName.unit,
-        name);
+    ElementLocationImpl location = new ElementLocationImpl.con3(
+        getReferencedLocationComponents(
+            exportName.dependency, exportName.unit, name));
     switch (exportName.kind) {
       case ReferenceKind.classOrEnum:
         return new ClassElementHandle(summaryResynthesizer, location);
       case ReferenceKind.typedef:
         return new FunctionTypeAliasElementHandle(
             summaryResynthesizer, location);
       case ReferenceKind.topLevelFunction:
         return new FunctionElementHandle(summaryResynthesizer, location);
       case ReferenceKind.topLevelPropertyAccessor:
         return new PropertyAccessorElementHandle(
@@ skipping 464 matching lines @@
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
     }
   }
 
   /**
-   * Build an [ElementLocationImpl] for the entity in the given [unit] of the
-   * given [dependency], having the given [name].
+   * Build the components of an [ElementLocationImpl] for the entity in the
+   * given [unit] of the dependency located at [dependencyIndex], and having
+   * the given [name].
    */
-  ElementLocationImpl getReferencedLocation(
-      LinkedDependency dependency, int unit, String name) {
+  List<String> getReferencedLocationComponents(
+      int dependencyIndex, int unit, String name) {
+    if (dependencyIndex == 0) {
+      String referencedLibraryUri = librarySource.uri.toString();
+      String partUri;
+      if (unit != 0) {
+        String uri = unlinkedUnits[0].publicNamespace.parts[unit - 1];
+        Source partSource =
+            summaryResynthesizer.sourceFactory.resolveUri(librarySource, uri);
+        partUri = partSource.uri.toString();
+      } else {
+        partUri = referencedLibraryUri;
+      }
+      return <String>[referencedLibraryUri, partUri, name];
+    }
+    LinkedDependency dependency = linkedLibrary.dependencies[dependencyIndex];
     Source referencedLibrarySource = summaryResynthesizer.sourceFactory
         .resolveUri(librarySource, dependency.uri);
     String referencedLibraryUri = referencedLibrarySource.uri.toString();
     // TODO(paulberry): consider changing Location format so that this is
     // not necessary (2nd string in location should just be the unit
     // number).
     String partUri;
     if (unit != 0) {
       UnlinkedUnit referencedLibraryDefiningUnit =
           summaryResynthesizer._getUnlinkedSummaryOrThrow(referencedLibraryUri);
       String uri =
           referencedLibraryDefiningUnit.publicNamespace.parts[unit - 1];
       Source partSource = summaryResynthesizer.sourceFactory
           .resolveUri(referencedLibrarySource, uri);
       partUri = partSource.uri.toString();
     } else {
       partUri = referencedLibraryUri;
     }
-    return new ElementLocationImpl.con3(
-        <String>[referencedLibraryUri, partUri, name]);
+    return <String>[referencedLibraryUri, partUri, name];
   }
 
   /**
    * Populate [referenceInfos] with the correct information for the current
    * compilation unit.
    */
   void populateReferenceInfos() {
     int numLinkedReferences = linkedUnit.references.length;
     int numUnlinkedReferences = unlinkedUnit.references.length;
     referenceInfos = new List<_ReferenceInfo>(numLinkedReferences);
     for (int i = 0; i < numLinkedReferences; i++) {
       LinkedReference linkedReference = linkedUnit.references[i];
       String name;
       if (i < numUnlinkedReferences) {
         name = unlinkedUnit.references[i].name;
       } else {
         name = linkedUnit.references[i].name;
       }
       ElementHandle element;
       DartType type;
       if (linkedReference.kind == ReferenceKind.unresolved) {
         type = summaryResynthesizer.typeProvider.undefinedType;
       } else if (name == 'dynamic') {
         type = summaryResynthesizer.typeProvider.dynamicType;
       } else if (name == 'void') {
         type = VoidTypeImpl.instance;
       } else {
-        ElementLocation location;
-        if (linkedReference.dependency != 0) {
-          location = getReferencedLocation(
-              linkedLibrary.dependencies[linkedReference.dependency],
-              linkedReference.unit,
-              name);
-        } else {
-          String referencedLibraryUri = librarySource.uri.toString();
-          String partUri;
-          if (linkedReference.unit != 0) {
-            String uri = unlinkedUnits[0].publicNamespace.parts[
-                linkedReference.unit - 1];
-            Source partSource = summaryResynthesizer.sourceFactory
-                .resolveUri(librarySource, uri);
-            partUri = partSource.uri.toString();
-          } else {
-            partUri = referencedLibraryUri;
-          }
-          location = new ElementLocationImpl.con3(
-              <String>[referencedLibraryUri, partUri, name]);
-        }
+        ElementLocation location = new ElementLocationImpl.con3(
+            getReferencedLocationComponents(
+                linkedReference.dependency, linkedReference.unit, name));
         switch (linkedReference.kind) {
           case ReferenceKind.classOrEnum:
             element = new ClassElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.typedef:
             element = new FunctionTypeAliasElementHandle(
                 summaryResynthesizer, location);
             break;
           default:
             // This is an element that doesn't (yet) need to be referred to
@@ skipping 150 matching lines @@
       return new InterfaceTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments);
     } else if (element is FunctionTypeAliasElementHandle) {
       return new FunctionTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments, typeArguments.isNotEmpty);
     } else {
       return null;
     }
   }
 }