anchor.diff:      }
     }
   
  -  Constant _handleInvocation(
  -      Expression node, Name name, Constant receiver, List<Constant> arguments,
  -      {List<DartType>? typeArguments, Map<String, Constant>? namedArguments}) {
  +  Constant _handleInvocation(Expression node, Name name, Constant receiver,
  +      List<Constant> positionalArguments,
  +      {required Arguments arguments}) {
       final String op = name.text;
   
       // TODO(kallentu): Handle all constant toString methods.
  
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 (shouldBeUnevaluated) {
        return unevaluated(
            node,
            new InstanceInvocation(node.kind, extract(receiver), node.name,
                unevaluatedArguments(arguments, {}, node.arguments.types),
                functionType: node.functionType,
                interfaceTarget: node.interfaceTarget)
              ..fileOffset = node.fileOffset
              ..flags = node.flags);
      }
  
      return _handleInvocation(node, node.name, receiver, arguments);
    }
  
    @override
  
negative.code:     } else if (receiver is NullConstant) {
        return createErrorConstant(node, messageConstEvalNullValue);
      } else if (receiver is ListConstant && enableConstFunctions) {
        if (positionalArguments.length == 1) {
          final Constant other = positionalArguments[0];
          switch (op) {
            case '[]':
              int? index = intFolder.asInt(other);
  