Change dependency walker's Node.dependencies to a static getter.

pkg/front_end/lib/src/dependency_walker.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.
 
 /**
  * Instances of [Node] represent nodes in a dependency graph.  The
  * type parameter, [NodeType], is the derived type (this affords some
  * extra type safety by making it difficult to accidentally construct
  * bridges between unrelated dependency graphs).
  */
 abstract class Node<NodeType> {
   /**
    * Index used by Tarjan's strongly connected components algorithm.
    * Zero means the node has not been visited yet; a nonzero value
    * counts the order in which the node was visited.
    */
   int _index = 0;
 
   /**
    * Low link used by Tarjan's strongly connected components
    * algorithm.  This represents the smallest [_index] of all the nodes
    * in the strongly connected component to which this node belongs.
    */
   int _lowLink = 0;
 
   List<NodeType> _dependencies;
 
   /**
-   * Retrieve the dependencies of this node.
-   */
-  List<NodeType> get dependencies => _dependencies ??= computeDependencies();
-
-  /**
    * Indicates whether this node has been evaluated yet.
    */
   bool get isEvaluated;
 
   /**
    * Compute the dependencies of this node.
    */
   List<NodeType> computeDependencies();
+
+  /**
+   * Gets the dependencies of the given node, computing them if necessary.
+   */
+  static List<NodeType> getDependencies<NodeType>(Node<NodeType> node) {
+    return node._dependencies ??= node.computeDependencies();
+  }
 }
 
 /**
  * An instance of [DependencyWalker] contains the core algorithms for
  * walking a dependency graph and evaluating nodes in a safe order.
  */
 abstract class DependencyWalker<NodeType extends Node<NodeType>> {
   /**
    * Called by [walk] to evaluate a single non-cyclical node, after
    * all that node's dependencies have been evaluated.
@@ skipping 38 matching lines @@
       bool hasTrivialCycle = false;
 
       // Assign the current node an index and add it to the stack.  We
       // haven't seen any of its dependencies yet, so set its lowLink
       // to its index, indicating that so far it is the only node in
       // its strongly connected component.
       node._index = node._lowLink = index++;
       stack.add(node);
 
       // Consider the node's dependencies one at a time.
-      for (NodeType dependency in node.dependencies) {
+      for (NodeType dependency in Node.getDependencies(node)) {
         // If the dependency has already been evaluated, it can't be
         // part of this node's strongly connected component, so we can
         // skip it.
         if (dependency.isEvaluated) {
           continue;
         }
         if (identical(node, dependency)) {
           // If a node includes itself as a dependency, there is no need to
           // explore the dependency further.
           hasTrivialCycle = true;
@@ skipping 48 matching lines @@
           }
           evaluateScc(scc);
         }
       }
     }
 
     // Kick off the algorithm starting with the starting point.
     strongConnect(startingPoint);
   }
 }