anchor.diff:      );
     }
   
  +  /// Removes a [variable] from a "promoted" [map], treating the map as
  +  /// immutable.
     Map<Variable, Type> _removePromoted(
         Map<Variable, Type> map, Variable variable) {
       if (map.isEmpty) return const {};
  
positive.code:     );
    }
  
    State<Variable, Type> restrict(
      TypeOperations<Variable, Type> typeOperations,
      _VariableSet<Variable> emptySet,
  
negative.code:   Expression unwrapParenthesized(Expression node);
  }
  
  /// An instance of the [State] class represents the information gathered by flow
  /// analysis at a single point in the control flow of the function or method
  /// being analyzed.
  ///
  /// Instances of this class are immuatable, so the methods below that "update"
  /// the state actually leave `this` unchanged and return a new state object.
  @visibleForTesting
  class State<Variable, Type> {
    /// Indicates whether this point in the control flow is reachable.
    final bool reachable;
  
    /// The set of variables that are not yet definitely assigned at this point in
    /// the control flow.
    final _VariableSet<Variable> notAssigned;
  
    /// For each variable whose type is promoted at this point in the control
    /// flow, the promoted type.  Variables whose type is not promoted are not
    /// present in the map.  Variables that have gone out of scope are not
    /// guaranteed to be present in the map even if they were promoted at the time
    /// they went out of scope.
    final Map<Variable, Type> promoted;
  
    /// Creates a state object with the given [reachable] status.  All variables
    /// are assumed to be unpromoted and already assigned, so joining another
    /// state with this one will have no effect on it.
    State(bool reachable)
        : this._(
            reachable,
  