anchor.diff:                  isNonNullableByDefault));
         }
       } else if (receiver is BoolConstant) {
  -      if (arguments.length == 1) {
  -        final Constant other = arguments[0];
  +      if (positionalArguments.length == 1) {
  +        final Constant other = positionalArguments[0];
           if (other is BoolConstant) {
             switch (op) {
               case '|':
  
positive.code:     final Constant receiver = _evaluateSubexpression(node.receiver);
      if (receiver is AbortConstant) return receiver;
  
      final List<Constant>? arguments =
          _evaluatePositionalArguments(node.arguments);
  
      if (arguments == null) {
        AbortConstant error = _gotError!;
        _gotError = null;
        return error;
      }
      assert(_gotError == null);
      // ignore: unnecessary_null_comparison
      assert(arguments != null);
  
      if (enableConstFunctions) {
        // Evaluate type arguments of the method invoked.
        List<DartType>? types = _evaluateTypeArguments(node, node.arguments);
        if (types == null) {
          AbortConstant error = _gotError!;
          _gotError = null;
          return error;
        }
        assert(_gotError == null);
        // ignore: unnecessary_null_comparison
        assert(types != null);
  
        // Evaluate named arguments of the method invoked.
        final Map<String, Constant>? named =
            _evaluateNamedArguments(node.arguments);
        if (named == null) {
          AbortConstant error = _gotError!;
          _gotError = null;
          return error;
        }
        assert(_gotError == null);
        // ignore: unnecessary_null_comparison
        assert(named != null);
  
        if (receiver is FunctionValue) {
          return _handleFunctionInvocation(
              receiver.function, types, arguments, named,
              functionEnvironment: receiver.environment);
        }
  
        return _handleInvocation(node, node.name, receiver, arguments,
            typeArguments: types, namedArguments: named);
      }
  
      if (shouldBeUnevaluated) {
        return unevaluated(
  
negative.code:         }
        }
      } else if (intFolder.isInt(receiver)) {
        if (positionalArguments.length == 0) {
          return canonicalize(intFolder.foldUnaryOperator(node, op, receiver));
        } else if (positionalArguments.length == 1) {
          final Constant other = positionalArguments[0];
          if (intFolder.isInt(other)) {
            return canonicalize(
                intFolder.foldBinaryOperator(node, op, receiver, other));
  