anchor.diff:      _propagateDownstream();
     }
   
  +  Iterable<_NullabilityEdge> _getDownstreamEdges(NullabilityNode node) {
  +    if (node is NullabilityNodeMutable) {
  +      return node._downstreamEdges;
  +    } else if (node == NullabilityNode.always) {
  +      return _downstreamFromAlways;
  +    } else {
  +      // No nodes are downstream from `never`.
  +      assert(node == NullabilityNode.never);
  +      return const [];
  +    }
  +  }
  +
     /// Propagates nullability downstream.
     void _propagateDownstream() {
  -    var pendingEdges = <_NullabilityEdge>[]
  -      ..addAll(_downstream[NullabilityNode.always] ?? const []);
  +    var pendingEdges = <_NullabilityEdge>[]..addAll(_downstreamFromAlways);
       var pendingSubstitutions = <NullabilityNodeForSubstitution>[];
       while (true) {
         nextEdge:
         while (pendingEdges.isNotEmpty) {
           var edge = pendingEdges.removeLast();
           var node = edge.destinationNode;
  -        if (_nonNullIntentNodes.contains(node)) {
  +        if (node.hasNonNullIntent) {
             // Non-null intent nodes are never made nullable; a null check will need
             // to be added instead.
             continue;
  
positive.code:   @visibleForTesting
    Iterable<NullabilityNode> getUpstreamNodesForTesting(
        NullabilityNode node) sync* {
      for (var entry in _downstream.entries) {
        for (var edge in entry.value) {
          if (edge.destinationNode == node) {
            yield entry.key;
          }
        }
      }
  
negative.code: /// Data structure to keep track of the relationship between [NullabilityNode]
  /// objects.
  class NullabilityGraph {
    /// Set containing all [NullabilityNode]s that have been passed as the
    /// `sourceNode` argument to [connect].
    final _allSourceNodes = Set<NullabilityNode>.identity();
  
    /// List of [_NullabilityEdge] objects that are downstream from
    /// [NullabilityNode.always].  (They can't be stored in
    /// [NullabilityNode.always] directly because it is immutable).
    final _downstreamFromAlways = <_NullabilityEdge>[];
  
    /// List of [NullabilityNodes] that are "upstream" from
    /// [NullabilityNode.never] due to unconditional control flow.  (They can't be
    /// stored in [NullabilityNode.never] directly because it is immutable).
    final _unconditionalUpstreamFromNever = <NullabilityNode>[];
  
    /// Records that [sourceNode] is immediately upstream from [destinationNode].
    void connect(NullabilityNode sourceNode, NullabilityNode destinationNode,
  