anchor.diff:    ///
     /// There is no guarantee of uniqueness of the iterated nodes.
     Iterable<NullabilityNode> getDownstreamNodes(NullabilityNode node) =>
  -      (_downstream[node] ?? const [])
  +      _getDownstreamEdges(node)
             .where((edge) => edge.primarySource == node)
             .map((edge) => edge.destinationNode);
   
  
positive.code:     var sources = [sourceNode]..addAll(guards);
      var edge = _NullabilityEdge(destinationNode, sources);
      for (var source in sources) {
        (_downstream[source] ??= []).add(edge);
      }
      if (unconditional) {
        (_unconditionalUpstream[destinationNode] ??= []).add(sourceNode);
      }
    }
  
    void debugDump() {
      for (var entry in _downstream.entries) {
        var destinations = entry.value
            .where((edge) => edge.primarySource == entry.key)
            .map((edge) {
          var suffixes = <Object>[];
          if (getUnconditionalUpstreamNodes(edge.destinationNode)
              .contains(entry.key)) {
            suffixes.add('unconditional');
          }
          suffixes.addAll(edge.guards);
  
negative.code:   /// Propagates non-null intent upstream along unconditional control flow
    /// lines.
    void _propagateUpstream() {
      var pendingNodes = <NullabilityNode>[]
        ..addAll(_unconditionalUpstreamFromNever);
      while (pendingNodes.isNotEmpty) {
        var node = pendingNodes.removeLast();
        if (node == NullabilityNode.always) {
          // The "always" node cannot have non-null intent.
          continue;
        }
        if (node is NullabilityNodeMutable && node._setNonNullIntent()) {
          // Was not previously in the set of non-null intent nodes, so we need to
          // propagate.
          pendingNodes.addAll(node._unconditionalUpstreamNodes);
        }
      }
    }
  