anchor.diff:      }
     }
   
  +  void _resolveNegation(PrefixExpressionImpl node, Expression operand) {
  +    InferenceContext.setType(operand, _typeProvider.boolType);
  +
  +    operand.accept(_resolver);
  +
  +    _recordStaticType(node, _nonNullable(_typeProvider.boolType));
  +
  +    _flowAnalysis?.flow?.logicalNot_end(node, operand);
  +  }
  +
     /// If the given [type] is a type parameter, resolve it to the type that should
     /// be used when looking up members. Otherwise, return the original type.
     ///
  
positive.code: 
    void _resolve2(PrefixExpressionImpl node) {
      TokenType operator = node.operator.type;
      if (operator == TokenType.BANG) {
        _recordStaticType(node, _nonNullable(_typeProvider.boolType));
      } else if (identical(node.operand.staticType, NeverTypeImpl.instance)) {
        _recordStaticType(node, NeverTypeImpl.instance);
      } else {
        // The other cases are equivalent to invoking a method.
  
negative.code:     var operand = node.operand;
  
      if (operator == TokenType.BANG) {
        _resolveNegation(node, operand);
        return;
      }
  
      operand.accept(_resolver);
  
      _resolve1(node);
      _resolve2(node);
    }
  
    /// Check that the result [type] of a prefix or postfix `++` or `--`
  