anchor.diff:      } else if (receiver is NullConstant) {
         return createErrorConstant(node, messageConstEvalNullValue);
       } else if (receiver is ListConstant && enableConstFunctions) {
  -      if (arguments.length == 1) {
  -        final Constant other = arguments[0];
  +      if (positionalArguments.length == 1) {
  +        final Constant other = positionalArguments[0];
           switch (op) {
             case '[]':
               int? index = intFolder.asInt(other);
  
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 DynamicInvocation(node.kind, extract(receiver), node.name,
                unevaluatedArguments(arguments, {}, node.arguments.types))
              ..fileOffset = node.fileOffset);
      }
  
      return _handleInvocation(node, node.name, receiver, arguments);
    }
  
    @override
  
negative.code:         }
        }
      } else if (receiver is MapConstant && enableConstFunctions) {
        if (positionalArguments.length == 1) {
          final Constant other = positionalArguments[0];
          switch (op) {
            case '[]':
              for (ConstantMapEntry entry in receiver.entries) {
  