Duplicate kernel package's graph.dart in analyzer, and prepare to publish 0.39.2+1.

Analyzer has dropped its dependency on kernel, so we can no longer
share this code.

This will allow us to re-publish analyzer and address issue #39702.

Bug: #39702
Change-Id: I20c3505c450dddb1e833fa6e56291ab39c32fe0c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/127560
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Reviewed-by: Jake Macdonald <jakemac@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>

Author: stereotype441

pkg/analyzer/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.39.2+1
+* Fixed bug #39702.
+
 ## 0.39.2
 * Deprecated `AnalysisSession.typeProvider` and `AnalysisSession.typeSystem`.
   Please use the corresponding getters in `LibraryElement` instead.

pkg/analyzer/lib/src/summary2/default_types_builder.dart

@@ -12,7 +12,7 @@ import 'package:analyzer/src/summary2/function_type_builder.dart';
 import 'package:analyzer/src/summary2/lazy_ast.dart';
 import 'package:analyzer/src/summary2/named_type_builder.dart';
 import 'package:analyzer/src/summary2/type_builder.dart';
-import 'package:kernel/util/graph.dart' show Graph, computeStrongComponents;
+import 'package:analyzer/src/util/graph.dart';
 
 class DefaultTypesBuilder {
   void build(List<AstNode> nodes) {

pkg/analyzer/lib/src/util/graph.dart

@@ -0,0 +1,77 @@
+// Copyright (c) 2017, 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.md file.
+
+abstract class Graph<T> {
+  Iterable<T> get vertices;
+
+  Iterable<T> neighborsOf(T vertex);
+}
+
+/// Computes the strongly connected components of [graph].
+///
+/// This implementation is based on [Dijkstra's path-based strong component
+/// algorithm]
+/// (https://en.wikipedia.org/wiki/Path-based_strong_component_algorithm#Description).
+List<List<T>> computeStrongComponents<T>(Graph<T> graph) {
+  List<List<T>> result = <List<T>>[];
+  int count = 0;
+  Map<T, int> preorderNumbers = <T, int>{};
+  List<T> unassigned = <T>[];
+  List<T> candidates = <T>[];
+  Set<T> assigned = new Set<T>();
+
+  void recursivelySearch(T vertex) {
+    // Step 1: Set the preorder number of [vertex] to [count], and increment
+    // [count].
+    preorderNumbers[vertex] = count++;
+
+    // Step 2: Push [vertex] onto [unassigned] and also onto [candidates].
+    unassigned.add(vertex);
+    candidates.add(vertex);
+
+    // Step 3: For each edge from [vertex] to a neighboring vertex [neighbor]:
+    for (T neighbor in graph.neighborsOf(vertex)) {
+      int neighborPreorderNumber = preorderNumbers[neighbor];
+      if (neighborPreorderNumber == null) {
+        // If the preorder number of [neighbor] has not yet been assigned,
+        // recursively search [neighbor];
+        recursivelySearch(neighbor);
+      } else if (!assigned.contains(neighbor)) {
+        // Otherwise, if [neighbor] has not yet been assigned to a strongly
+        // connected component:
+        //
+        // * Repeatedly pop vertices from [candidates] until the top element of
+        //   [candidates] has a preorder number less than or equal to the
+        //   preorder number of [neighbor].
+        while (preorderNumbers[candidates.last] > neighborPreorderNumber) {
+          candidates.removeLast();
+        }
+      }
+    }
+    // Step 4: If [vertex] is the top element of [candidates]:
+    if (candidates.last == vertex) {
+      // Pop vertices from [unassigned] until [vertex] has been popped, and
+      // assign the popped vertices to a new component.
+      List<T> component = <T>[];
+      while (true) {
+        T top = unassigned.removeLast();
+        component.add(top);
+        assigned.add(top);
+        if (top == vertex) break;
+      }
+      result.add(component);
+
+      // Pop [vertex] from [candidates].
+      candidates.removeLast();
+    }
+  }
+
+  for (T vertex in graph.vertices) {
+    if (preorderNumbers[vertex] == null) {
+      recursivelySearch(vertex);
+    }
+  }
+
+  return result;
+}

pkg/analyzer/pubspec.yaml

@@ -1,5 +1,5 @@
 name: analyzer
-version: 0.39.2
+version: 0.39.2+1
 author: Dart Team <misc@dartlang.org>
 description: This package provides a library that performs static analysis of Dart code.
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/analyzer