Rename _LinkedNode to _LinkNode in pub summary manager.

pkg/analyzer/lib/src/summary/pub_summary.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 'dart:async';
 import 'dart:collection';
 import 'dart:core';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 188 matching lines @@
 //    print('LOADED ${unlinkedBundles.length} unlinked bundles'
 //        ' in ${timer.elapsedMilliseconds} ms');
 //    timer..reset();
 
     // If no unlinked bundles, there is nothing we can try to link.
     if (unlinkedBundles.isEmpty) {
       return const <LinkedPubPackage>[];
     }
 
     // Create graph nodes for packages.
-    List<_LinkedNode> nodes = <_LinkedNode>[];
-    Map<String, _LinkedNode> packageToNode = <String, _LinkedNode>{};
+    List<_LinkNode> nodes = <_LinkNode>[];
+    Map<String, _LinkNode> packageToNode = <String, _LinkNode>{};
     unlinkedBundles.forEach((package, unlinked) {
-      _LinkedNode node = new _LinkedNode(sdkBundle, getDeclaredVariable,
+      _LinkNode node = new _LinkNode(sdkBundle, getDeclaredVariable,
           listedPackages, package, unlinked, packageToNode);
       nodes.add(node);
       packageToNode[package.name] = node;
     });
 
     // Compute transitive dependencies, mark some nodes as failed.
-    for (_LinkedNode node in nodes) {
+    for (_LinkNode node in nodes) {
       node.computeTransitiveDependencies();
     }
 
     // Attempt to read existing linked bundles.
-    for (_LinkedNode node in nodes) {
+    for (_LinkNode node in nodes) {
       _readLinked(node, strong);
     }
 
     // Link new bundles, if allowed.
     if (allowLinking) {
       // Fill the store with bundles.
       // Append the linked SDK bundle.
       // Append unlinked and (if read from a cache) linked package bundles.
       SummaryDataStore store = new SummaryDataStore(const <String>[]);
       store.addBundle(null, sdkBundle);
-      for (_LinkedNode node in nodes) {
+      for (_LinkNode node in nodes) {
         store.addBundle(null, node.unlinked);
         if (node.linked != null) {
           store.addBundle(null, node.linked);
         }
       }
 
       // Link each package node.
-      for (_LinkedNode node in nodes) {
+      for (_LinkNode node in nodes) {
         if (!node.isEvaluated) {
-          new _LinkedWalker(getDeclaredVariable, listedPackages, store, strong)
+          new _LinkWalker(getDeclaredVariable, listedPackages, store, strong)
               .walk(node);
         }
       }
 
       // Write newly linked bundles.
-      for (_LinkedNode node in nodes) {
+      for (_LinkNode node in nodes) {
         _writeLinked(node, strong);
       }
     }
 
     // Create successfully linked packages.
     List<LinkedPubPackage> linkedPackages = <LinkedPubPackage>[];
-    for (_LinkedNode node in nodes) {
+    for (_LinkNode node in nodes) {
       if (node.linked != null) {
         linkedPackages.add(new LinkedPubPackage(
             node.package, node.unlinked, node.linked, node.linkedHash));
       }
     }
 
     // TODO(scheglov) remove debug output after optimizing
 //    print('LINKED ${linkedPackages.length} bundles'
 //        ' in ${timer.elapsedMilliseconds} ms');
 
@@ skipping 236 matching lines @@
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
     Parser parser = new Parser(source, errorListener);
     parser.parseGenericMethodComments = strong;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = lineInfo;
     return unit;
   }
 
   /**
    * Attempt to find the linked bundle that corresponds to the given [node]
-   * with all its transitive dependencies and put it into [_LinkedNode.linked].
+   * with all its transitive dependencies and put it into [_LinkNode.linked].
    */
-  void _readLinked(_LinkedNode node, bool strong) {
+  void _readLinked(_LinkNode node, bool strong) {
     String hash = node.linkedHash;
     if (hash != null) {
       String fileName = _getLinkedName(hash, strong);
       File file = node.package.folder.getChildAssumingFile(fileName);
       // Try to find in the cache.
       PackageBundle linked = linkedBundleMap[file.path];
       if (linked != null) {
         node.linked = linked;
         return;
       }
@@ skipping 38 matching lines @@
     String filePath = folder.getChildAssumingFile(fileName).path;
     File tempFile = folder.getChildAssumingFile(tempFileName);
     tempFile.writeAsBytesSync(bytes);
     tempFile.renameSync(filePath);
   }
 
   /**
    * If a new linked bundle was linked for the given [node], write the bundle
    * into the memory cache and the file system.
    */
-  void _writeLinked(_LinkedNode node, bool strong) {
+  void _writeLinked(_LinkNode node, bool strong) {
     String hash = node.linkedHash;
     if (hash != null && node.linkedNewBytes != null) {
       String fileName = _getLinkedName(hash, strong);
       File file = node.package.folder.getChildAssumingFile(fileName);
       linkedBundleMap[file.path] = node.linked;
       _writeAtomic(node.package.folder, fileName, node.linkedNewBytes);
     }
   }
 
   /**
@@ skipping 26 matching lines @@
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * Specialization of [Node] for linking packages in proper dependency order.
  */
-class _LinkedNode extends Node<_LinkedNode> {
+class _LinkNode extends Node<_LinkNode> {
   final PackageBundle sdkBundle;
   final _GetDeclaredVariable getDeclaredVariable;
   final _ListedPackages listedPackages;
   final PubPackage package;
   final PackageBundle unlinked;
-  final Map<String, _LinkedNode> packageToNode;
+  final Map<String, _LinkNode> packageToNode;
 
   bool failed = false;
-  Set<_LinkedNode> transitiveDependencies;
+  Set<_LinkNode> transitiveDependencies;
   String _linkedHash;
 
   List<int> linkedNewBytes;
   PackageBundle linked;
 
-  _LinkedNode(this.sdkBundle, this.getDeclaredVariable, this.listedPackages,
+  _LinkNode(this.sdkBundle, this.getDeclaredVariable, this.listedPackages,
       this.package, this.unlinked, this.packageToNode);
 
   @override
   bool get isEvaluated => linked != null || failed;
 
   /**
    * Return the hash string that corresponds to this linked bundle in the
    * context of its [sdkBundle] and transitive dependencies.  Return `null` if
    * the hash computation fails, because for example the full transitive
    * dependencies cannot computed.
@@ skipping 10 matching lines @@
       signatures.sort();
       signatures.forEach(signature.addString);
       // Combine into a single hash.
       _appendDeclaredVariables(signature);
       _linkedHash = signature.toHex();
     }
     return _linkedHash;
   }
 
   @override
-  List<_LinkedNode> computeDependencies() {
-    Set<_LinkedNode> dependencies = new Set<_LinkedNode>();
+  List<_LinkNode> computeDependencies() {
+    Set<_LinkNode> dependencies = new Set<_LinkNode>();
 
     void appendDependency(String uriStr) {
       Uri uri = FastUri.parse(uriStr);
       if (!uri.hasScheme) {
         // A relative path in this package, skip it.
       } else if (uri.scheme == 'dart') {
         // Dependency on the SDK is implicit and always added.
         // The SDK linked bundle is precomputed before linking packages.
       } else if (uriStr.startsWith('package:')) {
         String package = PubSummaryManager.getPackageName(uriStr);
-        _LinkedNode packageNode = packageToNode[package];
+        _LinkNode packageNode = packageToNode[package];
         if (packageNode == null && listedPackages.isListed(uriStr)) {
           failed = true;
         }
         if (packageNode != null) {
           dependencies.add(packageNode);
         }
       } else {
         failed = true;
       }
     }
@@ skipping 13 matching lines @@
   }
 
   /**
    * Compute the set of existing transitive dependencies for this node.
    * If any `package` dependency cannot be resolved, but it is one of the
    * [listedPackages] then set [failed] to `true`.
    * Only [unlinked] is used, so this method can be called before linking.
    */
   void computeTransitiveDependencies() {
     if (transitiveDependencies == null) {
-      transitiveDependencies = new Set<_LinkedNode>();
+      transitiveDependencies = new Set<_LinkNode>();
 
-      void appendDependencies(_LinkedNode node) {
+      void appendDependencies(_LinkNode node) {
         if (transitiveDependencies.add(node)) {
           node.dependencies.forEach(appendDependencies);
         }
       }
 
       appendDependencies(this);
       if (transitiveDependencies.any((node) => node.failed)) {
         failed = true;
       }
     }
   }
 
   @override
   String toString() => package.toString();
 
   /**
    * Append names and values of all referenced declared variables (even the
    * ones without actually declared values) to the given [signature].
    */
   void _appendDeclaredVariables(ApiSignature signature) {
     Set<String> nameSet = new Set<String>();
-    for (_LinkedNode node in transitiveDependencies) {
+    for (_LinkNode node in transitiveDependencies) {
       for (UnlinkedUnit unit in node.unlinked.unlinkedUnits) {
         for (UnlinkedImport import in unit.imports) {
           for (UnlinkedConfiguration configuration in import.configurations) {
             nameSet.add(configuration.name);
           }
         }
         for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
           for (UnlinkedConfiguration configuration in export.configurations) {
             nameSet.add(configuration.name);
           }
         }
       }
     }
     List<String> sortedNameList = nameSet.toList()..sort();
     signature.addInt(sortedNameList.length);
     for (String name in sortedNameList) {
       signature.addString(name);
       signature.addString(getDeclaredVariable(name) ?? '');
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for linking packages.
  */
-class _LinkedWalker extends DependencyWalker<_LinkedNode> {
+class _LinkWalker extends DependencyWalker<_LinkNode> {
   final _GetDeclaredVariable getDeclaredVariable;
   final _ListedPackages listedPackages;
   final SummaryDataStore store;
   final bool strong;
 
-  _LinkedWalker(
+  _LinkWalker(
       this.getDeclaredVariable, this.listedPackages, this.store, this.strong);
 
   @override
-  void evaluate(_LinkedNode node) {
+  void evaluate(_LinkNode node) {
     evaluateScc([node]);
   }
 
   @override
-  void evaluateScc(List<_LinkedNode> scc) {
-    Map<String, _LinkedNode> uriToNode = <String, _LinkedNode>{};
-    for (_LinkedNode node in scc) {
+  void evaluateScc(List<_LinkNode> scc) {
+    Map<String, _LinkNode> uriToNode = <String, _LinkNode>{};
+    for (_LinkNode node in scc) {
       for (String uri in node.unlinked.unlinkedUnitUris) {
         uriToNode[uri] = node;
       }
     }
     Set<String> libraryUris = uriToNode.keys.toSet();
     // Perform linking.
     Map<String, LinkedLibraryBuilder> linkedLibraries =
         link(libraryUris, (String uri) {
       return store.linkedMap[uri];
     }, (String uri) {
       return store.unlinkedMap[uri];
     }, getDeclaredVariable, strong);
     // Assemble linked bundles and put them into the store.
-    for (_LinkedNode node in scc) {
+    for (_LinkNode node in scc) {
       PackageBundleAssembler assembler = new PackageBundleAssembler();
       linkedLibraries.forEach((uri, linkedLibrary) {
         if (identical(uriToNode[uri], node)) {
           assembler.addLinkedLibrary(uri, linkedLibrary);
         }
       });
       List<int> bytes = assembler.assemble().toBuffer();
       node.linkedNewBytes = bytes;
       node.linked = new PackageBundle.fromBuffer(bytes);
       store.addBundle(null, node.linked);
@@ skipping 18 matching lines @@
   }
 
   /**
    * Check whether the given `package:` [uri] is listed in the package map.
    */
   bool isListed(String uri) {
     String package = PubSummaryManager.getPackageName(uri);
     return names.contains(package);
   }
 }