anchor.diff:    /// Set containing all sources being migrated.
     final _sourcesBeingMigrated = <Source>{};
   
  +  /// After execution of [_propagateAlways], a list of all nodes reachable from
  +  /// [always] via zero or more edges of kind [_NullabilityEdgeKind.union].
  +  final List<NullabilityNode> _unionedWithAlways = [];
  +
  +  /// During any given stage of nullability propagation, a list of all the edges
  +  /// that need to be examined before the stage is complete.
  +  final List<NullabilityEdge> _pendingEdges = [];
  +
  +  /// During and after nullability propagation, a list of all edges that
  +  /// couldn't be satisfied.
  +  final List<NullabilityEdge> _unsatisfiedEdges = [];
  +
  +  /// During execution of [_propagateDownstream], a list of all the substitution
  +  /// nodes that have not yet been resolved.
  +  final List<NullabilityNodeForSubstitution> _pendingSubstitutions = [];
  +
     /// Records that [sourceNode] is immediately upstream from [destinationNode].
     ///
     /// Returns the edge created by the connection.
  
positive.code:   }
  
    /// Propagates nullability downstream along union edges from "always".
    ///
    /// Returns a list of nodes that are nullable after this operation (including
    /// "always")
    List<NullabilityNode> _propagateAlways() {
      var nullableNodes = <NullabilityNode>[always];
      var pendingEdges = always._downstreamEdges.toList();
      while (pendingEdges.isNotEmpty) {
        var edge = pendingEdges.removeLast();
        if (!edge.isUnion) continue;
        // Union edges always have exactly one source, so we don't need to check
        // whether all sources are nullable.
        assert(edge.sources.length == 1);
        var node = edge.destinationNode;
        if (node is NullabilityNodeMutable && !node.isNullable) {
          nullableNodes.add(node);
          node._state = _NullabilityState.ordinaryNullable;
          // Was not previously nullable, so we need to propagate.
          pendingEdges.addAll(node._downstreamEdges);
        }
      }
      return nullableNodes;
    }
  
    /// Propagates nullability downstream.
    List<NullabilityEdge> _propagateDownstream(
        List<NullabilityNode> nullableNodes) {
      var unsatisfiedEdges = <NullabilityEdge>[];
      var pendingEdges = <NullabilityEdge>[];
      for (var node in nullableNodes) {
        pendingEdges.addAll(node._downstreamEdges);
      }
      var pendingSubstitutions = <NullabilityNodeForSubstitution>[];
      while (true) {
        while (pendingEdges.isNotEmpty) {
          var edge = pendingEdges.removeLast();
          if (!edge._isTriggered) continue;
          var node = edge.destinationNode;
          if (node._state == _NullabilityState.nonNullable) {
            // The node has already been marked as non-nullable, so the edge can't
            // be satisfied.
            unsatisfiedEdges.add(edge);
            continue;
          }
          if (node is NullabilityNodeMutable && !node.isNullable) {
            node._state = _NullabilityState.ordinaryNullable;
            // Was not previously nullable, so we need to propagate.
            pendingEdges.addAll(node._downstreamEdges);
            if (node is NullabilityNodeForSubstitution) {
              pendingSubstitutions.add(node);
            }
          }
        }
        if (pendingSubstitutions.isEmpty) break;
        var node = pendingSubstitutions.removeLast();
        if (node.innerNode.isNullable || node.outerNode.isNullable) {
          // No further propagation is needed, since some other connection already
          // propagated nullability to either the inner or outer node.
  
negative.code:   /// Returns a list of edges that couldn't be satisfied.
    List<NullabilityEdge> propagate() {
      if (_debugBeforePropagation) _debugDump();
      _propagateAlways();
      _propagateUpstream();
      _propagateDownstream();
      return _unsatisfiedEdges;
    }
  
    /// Records that nodes [x] and [y] should have exactly the same nullability.
  