json 2.21.2 → 3.1.0

data/ext/json/ext/parser/parser.c

@@ -5,7 +5,7 @@
 static VALUE mJSON, eNestingError, eParserError, Encoding_UTF_8;
 static VALUE CNaN, CInfinity, CMinusInfinity, JSON_empty_string;
 
-static ID i_new, i_try_convert, i_encode, i_at_line, i_at_column;
+static ID i_new, i_try_convert, i_encode, i_at_line, i_at_column, i_at_json_path;
 #ifndef HAVE_RB_STR_TO_INTERNED_STR
 static ID i_uminus;
 #endif
@@ -20,9 +20,9 @@ static int utf8_encindex;
 #ifndef HAVE_RB_HASH_BULK_INSERT
 // For TruffleRuby
 static void
-rb_hash_bulk_insert(long count, const VALUE *pairs, VALUE hash)
+rb_hash_bulk_insert(rb_len_t count, const VALUE *pairs, VALUE hash)
 {
-    long index = 0;
+    rb_len_t index = 0;
     while (index < count) {
         VALUE name = pairs[index++];
         VALUE value = pairs[index++];
@@ -79,7 +79,7 @@ static rb_encoding *enc_utf8;
 
 #define JSON_RVALUE_CACHE_MAX_ENTRY_LENGTH 55
 
-static inline VALUE build_interned_string(const char *str, const long length)
+static inline VALUE build_interned_string(const char *str, const rb_len_t length)
 {
 # ifdef HAVE_RB_ENC_INTERNED_STR
     return rb_enc_interned_str(str, length, enc_utf8);
@@ -89,7 +89,7 @@ static inline VALUE build_interned_string(const char *str, const long length)
 # endif
 }
 
-static inline VALUE build_symbol(const char *str, const long length)
+static inline VALUE build_symbol(const char *str, const rb_len_t length)
 {
     return rb_str_intern(build_interned_string(str, length));
 }
@@ -138,7 +138,7 @@ ALWAYS_INLINE(static) int rstring_cache_memcmp(const char *str, const char *rptr
 ALWAYS_INLINE(static) int rstring_cache_cmp(const char *str, const long length, VALUE rstring)
 {
     const char *rstring_ptr;
-    long rstring_length;
+    rb_len_t rstring_length;
 
     RSTRING_GETMEM(rstring, rstring_ptr, rstring_length);
 
@@ -323,14 +323,17 @@ static const rb_data_type_t JSON_Parser_rvalue_stack_type = {
 static rvalue_stack *rvalue_stack_spill(rvalue_stack *old_stack, VALUE *handle, rvalue_stack **stack_ref)
 {
     rvalue_stack *stack;
-    *handle = TypedData_Make_Struct(0, rvalue_stack, &JSON_Parser_rvalue_stack_type, stack);
-    *stack_ref = stack;
+    VALUE stack_handle = TypedData_Make_Struct(0, rvalue_stack, &JSON_Parser_rvalue_stack_type, stack);
     MEMCPY(stack, old_stack, rvalue_stack, 1);
 
     stack->capa = old_stack->capa << 1;
     stack->ptr = ALLOC_N(VALUE, stack->capa);
     stack->type = RVALUE_STACK_HEAP_ALLOCATED;
     MEMCPY(stack->ptr, old_stack->ptr, VALUE, old_stack->head);
+
+    *handle = stack_handle;
+    *stack_ref = stack;
+
     return stack;
 }
 
@@ -403,19 +406,13 @@ typedef struct json_frame_stack_struct {
     json_frame *ptr;
 } json_frame_stack;
 
-enum deprecatable_action {
-    JSON_DEPRECATED = 0,
-    JSON_IGNORE,
-    JSON_RAISE,
-};
-
 typedef struct JSON_ParserStruct {
     VALUE on_load_proc;
     VALUE decimal_class;
     ID decimal_method_id;
-    enum deprecatable_action on_duplicate_key;
-    enum deprecatable_action on_comment;
     int max_nesting;
+    bool allow_comments;
+    bool allow_duplicate_key;
     bool allow_nan;
     bool allow_trailing_comma;
     bool allow_control_characters;
@@ -435,7 +432,6 @@ typedef struct JSON_ParserStateStruct {
     rvalue_cache name_cache;
     int in_array;
     int current_nesting;
-    unsigned int emitted_deprecations;
     VALUE parser;
 } JSON_ParserState;
 
@@ -587,7 +583,7 @@ static inline char peek(JSON_ParserState *state)
     return *state->cursor;
 }
 
-static void cursor_position(JSON_ParserState *state, long *line_out, long *column_out)
+static void cursor_position(JSON_ParserState *state, long *line_out, rb_len_t *column_out)
 {
     JSON_ASSERT(!state->parser);
     JSON_ASSERT(state->cursor);
@@ -599,19 +595,15 @@ static void cursor_position(JSON_ParserState *state, long *line_out, long *colum
     }
 
     const char *cursor = state->cursor;
-    long column = 0;
     long line = 1;
 
-    while (cursor >= state->start) {
-        if (*cursor-- == '\n') {
-            line++;
-            break;
-        }
-        column++;
+    while (cursor > state->start && cursor[-1] != '\n') {
+        cursor--;
     }
+    rb_len_t column = rb_enc_strlen(cursor, state->cursor, enc_utf8) + 1;
 
-    while (cursor >= state->start) {
-        if (*cursor-- == '\n') {
+    while (cursor > state->start) {
+        if (*--cursor == '\n') {
             line++;
         }
     }
@@ -619,21 +611,6 @@ static void cursor_position(JSON_ParserState *state, long *line_out, long *colum
     *column_out = column;
 }
 
-static const unsigned int MAX_DEPRECATIONS = 5;
-
-static void emit_parse_warning(const char *message, JSON_ParserState *state)
-{
-    VALUE warning;
-    if (state->parser) { // line and columns can't be accurate in resumable
-        warning = rb_utf8_str_new_cstr(message);
-    } else {
-        long line, column;
-        cursor_position(state, &line, &column);
-        warning = rb_sprintf("%s at line %ld column %ld", message, line, column);
-    }
-    rb_funcall(mJSON, rb_intern("deprecation_warning"), 1, warning);
-}
-
 #define PARSE_ERROR_FRAGMENT_LEN 32
 
 static VALUE build_parse_error_message(const char *format, JSON_ParserState *state)
@@ -653,17 +630,15 @@ static VALUE build_parse_error_message(const char *format, JSON_ParserState *sta
         }
 
         if (len) {
-            buffer[0] = '\'';
-            MEMCPY(buffer + 1, ptr, char, len);
-
-            while (buffer[len] >= 0x80 && buffer[len] < 0xC0) { // Is continuation byte
-                len--;
-            }
-
-            if (buffer[len] >= 0xC0) { // multibyte character start
-                len--;
+            if (len == PARSE_ERROR_FRAGMENT_LEN) {
+                // Only trim when the byte limit splits a multibyte character.
+                while (len && (unsigned char)ptr[len] >= 0x80 && (unsigned char)ptr[len] < 0xC0) {
+                    len--;
+                }
             }
 
+            buffer[0] = '\'';
+            MEMCPY(buffer + 1, ptr, char, len);
             buffer[len + 1] = '\'';
             buffer[len + 2] = '\0';
             ptr = (const char *)buffer;
@@ -673,11 +648,42 @@ static VALUE build_parse_error_message(const char *format, JSON_ParserState *sta
     return rb_enc_sprintf(enc_utf8, format, ptr);
 }
 
-static VALUE parse_error_new(JSON_ParserState *state, VALUE message, long line, long column, bool eos)
+static VALUE json_path_new(JSON_ParserState *state, VALUE duplicate_key)
+{
+    VALUE path = rb_ary_new_capa(state->current_nesting);
+
+    json_frame_stack *frames = state->frames;
+    rvalue_stack *values = state->value_stack;
+
+    for (long depth = 1; depth < frames->head; depth++) {
+        json_frame *frame = &frames->ptr[depth];
+
+        bool innermost = depth == frames->head - 1;
+        long child_head = innermost ? values->head : frames->ptr[depth + 1].value_stack_head;
+        long count = child_head - frame->value_stack_head;
+
+        if (frame->type == JSON_FRAME_ARRAY) {
+            rb_ary_push(path, LONG2NUM(frame->phase == JSON_PHASE_ARRAY_COMMA ? count - 1 : count));
+        } else if (innermost && !UNDEF_P(duplicate_key)) {
+            rb_ary_push(path, duplicate_key);
+        } else if (count & 1) {
+            rb_ary_push(path, values->ptr[child_head - 1]);
+        } else if (frame->phase == JSON_PHASE_OBJECT_COMMA && count >= 2) {
+            rb_ary_push(path, values->ptr[child_head - 2]);
+        } else {
+            break;
+        }
+    }
+
+    return path;
+}
+
+static VALUE parse_error_new(JSON_ParserState *state, VALUE message, long line, rb_len_t column, bool eos)
 {
     VALUE exc = rb_exc_new_str(eParserError, message);
     rb_ivar_set(exc, i_at_line, LONG2NUM(line));
-    rb_ivar_set(exc, i_at_column, LONG2NUM(column));
+    rb_ivar_set(exc, i_at_column, LEN2NUM(column));
+    rb_ivar_set(exc, i_at_json_path, json_path_new(state, Qundef));
     return exc;
 }
 
@@ -694,9 +700,10 @@ NORETURN(static) void raise_parse_error(const char *format, JSON_ParserState *st
         }
     } else {
         VALUE message = build_parse_error_message(format, state);
-        long line, column;
+        long line;
+        rb_len_t column;
         cursor_position(state, &line, &column);
-        rb_str_catf(message, " at line %ld column %ld", line, column);
+        rb_str_catf(message, " at line %ld column %"PRIdLEN, line, column);
         rb_exc_raise(parse_error_new(state, message, line, column, eos));
     }
 }
@@ -749,7 +756,7 @@ static const signed char digit_values[256] = {
 static uint32_t unescape_unicode(JSON_ParserState *state, const char *sp, const char *spe)
 {
     if (RB_UNLIKELY(sp > spe - 4)) {
-        raise_eos_error_at("incomplete unicode character escape sequence at %s", state, sp - 2);
+        raise_syntax_error_at("incomplete unicode character escape sequence at %s", state, sp - 2);
     }
 
     const unsigned char *p = (const unsigned char *)sp;
@@ -772,11 +779,10 @@ static uint32_t unescape_unicode(JSON_ParserState *state, const char *sp, const
 
 static const rb_data_type_t JSON_ParserConfig_type;
 
-const char *COMMENT_DEPRECATION_MESSAGE = "Encountered comment in JSON. This will raise an error in json 3.0 unless enabled via `allow_comments: true`";
 NOINLINE(static) void
 json_eat_comments(JSON_ParserState *state, JSON_ParserConfig *config, const char *resume_pos)
 {
-    if (config->on_comment == JSON_RAISE) {
+    if (!config->allow_comments) {
         raise_syntax_error("unexpected token %s", state);
     }
 
@@ -826,11 +832,6 @@ json_eat_comments(JSON_ParserState *state, JSON_ParserConfig *config, const char
             raise_parse_error_at("unexpected token %s", state, eos(state) ? rewind_pos : start, eos(state));
             break;
     }
-
-    if (config->on_comment == JSON_DEPRECATED && state->emitted_deprecations < MAX_DEPRECATIONS) {
-        state->emitted_deprecations++;
-        emit_parse_warning(COMMENT_DEPRECATION_MESSAGE, state);
-    }
 }
 
 ALWAYS_INLINE(static) void
@@ -892,12 +893,12 @@ static inline VALUE build_string(const char *start, const char *end, bool intern
     VALUE result;
 # ifdef HAVE_RB_ENC_INTERNED_STR
     if (intern) {
-      result = rb_enc_interned_str(start, (long)(end - start), enc_utf8);
+      result = rb_enc_interned_str(start, (rb_len_t)(end - start), enc_utf8);
     } else {
-      result = rb_utf8_str_new(start, (long)(end - start));
+      result = rb_utf8_str_new(start, (rb_len_t)(end - start));
     }
 # else
-    result = rb_utf8_str_new(start, (long)(end - start));
+    result = rb_utf8_str_new(start, (rb_len_t)(end - start));
     if (intern) {
         result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
     }
@@ -1038,6 +1039,9 @@ NOINLINE(static) VALUE json_string_unescape(JSON_ParserState *state, JSON_Parser
                         raise_syntax_error_at("incomplete surrogate pair at %s", state, p);
                         break;
                     }
+                } else if ((ch & 0xFC00) == 0xDC00) {
+                    raise_syntax_error_at("unpaired trailing surrogate at %s", state, p);
+                    break;
                 }
 
                 int unescape_len = convert_UTF32_to_UTF8(buffer, ch);
@@ -1045,13 +1049,13 @@ NOINLINE(static) VALUE json_string_unescape(JSON_ParserState *state, JSON_Parser
                 p = ++pe;
                 break;
             }
-            case 0:
-              return Qundef;
             default:
                 if ((unsigned char)*pe < 0x20) {
                     if (!config->allow_control_characters) {
                         if (*pe == '\n') {
                             raise_syntax_error_at("Invalid unescaped newline character (\\n) in string: %s", state, pe - 1);
+                        } else if (*pe == '\0') {
+                            raise_syntax_error_at("Invalid unescaped NULL character (\\0) in string: %s", state, pe - 1);
                         }
                         raise_syntax_error_at("invalid ASCII control character in string: %s", state, pe - 1);
                     }
@@ -1082,12 +1086,13 @@ NOINLINE(static) VALUE json_string_unescape(JSON_ParserState *state, JSON_Parser
     return result;
 }
 
-#define MAX_FAST_INTEGER_SIZE 18
+#define MAX_FAST_INTEGER_SIZE 19
+#define MAX_FAST_UINT64_SIZE  20
 #define MAX_NUMBER_STACK_BUFFER 128
 
 typedef VALUE (*json_number_decode_func_t)(const char *ptr);
 
-static inline VALUE json_decode_large_number(const char *start, long len, json_number_decode_func_t func)
+static inline VALUE json_decode_large_number(const char *start, rb_len_t len, json_number_decode_func_t func)
 {
     if (RB_LIKELY(len < MAX_NUMBER_STACK_BUFFER)) {
         char buffer[MAX_NUMBER_STACK_BUFFER];
@@ -1110,18 +1115,37 @@ static VALUE json_decode_inum(const char *buffer)
     return rb_cstr2inum(buffer, 10);
 }
 
-NOINLINE(static) VALUE json_decode_large_integer(const char *start, long len)
+NOINLINE(static) VALUE json_decode_large_integer(const char *start, rb_len_t len)
 {
     return json_decode_large_number(start, len, json_decode_inum);
 }
 
 static inline VALUE json_decode_integer(uint64_t mantissa, int mantissa_digits, bool negative, const char *start, const char *end)
 {
-    if (RB_LIKELY(mantissa_digits < MAX_FAST_INTEGER_SIZE)) {
-        if (negative) {
+    if (RB_LIKELY(mantissa_digits <= MAX_FAST_INTEGER_SIZE)) {
+        if (RB_LIKELY(!negative)) {
+            return UINT64T2NUM(mantissa);
+        }
+
+        // For a negative number 19 digits in length, we only get half of the range,
+        // so ensure this negative number is less than INT64_MAX. 
+        //
+        // Note: This does miss INT64_MIN as it's value is one past INT64_MAX
+        // when converted to a uint64_t. It will still be parsed correctly by 
+        // falling through to json_decode_large_integer.
+        if (RB_LIKELY(mantissa <= (uint64_t)INT64_MAX)) {
             return INT64T2NUM(-((int64_t)mantissa));
         }
-        return UINT64T2NUM(mantissa);
+    }
+
+    if (!negative && mantissa_digits == MAX_FAST_UINT64_SIZE) {
+        // Not all 20 digit integers can be safely represented by a uint64_t but
+        // some can. The memcmp with uint64_max is safe as we've rejected leading
+        // zeros and we have guaranteed we're comparing it with a 20 digit number.
+        static const char uint64_max[] = "18446744073709551615";
+        if (memcmp(end - MAX_FAST_UINT64_SIZE, uint64_max, MAX_FAST_UINT64_SIZE) <= 0) {
+            return UINT64T2NUM(mantissa);
+        }
     }
 
     return json_decode_large_integer(start, end - start);
@@ -1132,7 +1156,7 @@ static VALUE json_decode_dnum(const char *buffer)
     return DBL2NUM(rb_cstr_to_dbl(buffer, 1));
 }
 
-NOINLINE(static) VALUE json_decode_large_float(const char *start, long len)
+NOINLINE(static) VALUE json_decode_large_float(const char *start, rb_len_t len)
 {
     return json_decode_large_number(start, len, json_decode_dnum);
 }
@@ -1148,11 +1172,11 @@ static inline VALUE json_decode_float(JSON_ParserConfig *config, uint64_t mantis
         return rb_funcallv(config->decimal_class, config->decimal_method_id, 1, &text);
     }
 
-    if (RB_UNLIKELY(exponent > INT32_MAX)) {
+    if (RB_UNLIKELY(exponent >= (int64_t)INT32_MAX)) {
         return negative ? CMinusInfinity : CInfinity;
     }
 
-    if (RB_UNLIKELY(exponent < INT32_MIN)) {
+    if (RB_UNLIKELY(exponent <= INT32_MIN)) {
         return rb_float_new(negative ? -0.0 : 0.0);
     }
 
@@ -1199,17 +1223,6 @@ static VALUE json_find_duplicated_key(size_t count, const VALUE *pairs)
     return Qfalse;
 }
 
-NOINLINE(static) void emit_duplicate_key_warning(JSON_ParserState *state, VALUE duplicate_key)
-{
-    VALUE message = rb_sprintf(
-        "detected duplicate key %"PRIsVALUE" in JSON object. This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`",
-        rb_inspect(duplicate_key)
-    );
-
-    emit_parse_warning(RSTRING_PTR(message), state);
-    RB_GC_GUARD(message);
-}
-
 NORETURN(static) void raise_duplicate_key_error(JSON_ParserState *state, VALUE duplicate_key)
 {
     VALUE message = rb_sprintf(
@@ -1218,35 +1231,25 @@ NORETURN(static) void raise_duplicate_key_error(JSON_ParserState *state, VALUE d
     );
 
     rb_str_concat(message, build_parse_error_message("", state));
+    VALUE exc;
     if (state->parser) { // line and columns can't be accurate in resumable
-        rb_exc_raise(parse_error_new(state, message, 0, 0, false));
+        exc = parse_error_new(state, message, 0, 0, false);
     } else {
-        long line, column;
+        long line;
+        rb_len_t column;
         cursor_position(state, &line, &column);
-        rb_str_catf(message, " at line %ld column %ld", line, column);
-        rb_exc_raise(parse_error_new(state, message, line, column, false));
+        rb_str_catf(message, " at line %ld column %"PRIdLEN, line, column);
+        exc = parse_error_new(state, message, line, column, false);
     }
+    rb_ivar_set(exc, i_at_json_path, json_path_new(state, duplicate_key));
+    rb_exc_raise(exc);
 }
 
 NOINLINE(static) void json_on_duplicate_key(JSON_ParserState *state, JSON_ParserConfig *config, size_t count, const VALUE *pairs)
 {
-    switch (config->on_duplicate_key) {
-        case JSON_IGNORE:
-            return;
-
-        case JSON_DEPRECATED:
-            // Only emit the first few deprecations to avoid spamming.
-            if (state->emitted_deprecations < MAX_DEPRECATIONS) {
-                state->emitted_deprecations++;
-                emit_duplicate_key_warning(state, json_find_duplicated_key(count, pairs));
-            }
-            return;
-
-        case JSON_RAISE:
-            raise_duplicate_key_error(state, json_find_duplicated_key(count, pairs));
-            return;
+    if (!config->allow_duplicate_key) {
+        raise_duplicate_key_error(state, json_find_duplicated_key(count, pairs));
     }
-    UNREACHABLE;
 }
 
 static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfig *config, size_t count)
@@ -1514,7 +1517,7 @@ static inline VALUE json_parse_number(JSON_ParserState *state, JSON_ParserConfig
         }
 
         if (RB_UNLIKELY(exponent_digits >= 20 || abs_exponent > (uint64_t)INT64_MAX)) {
-            exponent = negative_exponent ? INT64_MIN : INT64_MAX;
+            exponent = negative_exponent ? INT32_MIN : INT32_MAX;
         } else {
             exponent = negative_exponent ? -(int64_t)abs_exponent : (int64_t)abs_exponent;
         }
@@ -1811,7 +1814,7 @@ ALWAYS_INLINE(static) bool json_parse_any(JSON_ParserState *state, JSON_ParserCo
         if (RB_LIKELY(peek(state) == '"')) {
             VALUE string = json_parse_string(state, config, true);
             if (UNDEF_P(string)) {
-                if (resumable) {
+                if (resumable && eos(state)) {
                     state->cursor = start;
                     return false;
                 } else {
@@ -2012,13 +2015,21 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
          if (key == sym_max_nesting)                { config->max_nesting = RTEST(val) ? FIX2INT(val) : 0; }
     else if (key == sym_allow_nan)                  { config->allow_nan = RTEST(val); }
     else if (key == sym_allow_trailing_comma)       { config->allow_trailing_comma = RTEST(val); }
-    else if (key == sym_allow_comments)             { config->on_comment = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
+    else if (key == sym_allow_comments)             { config->allow_comments = RTEST(val); }
     else if (key == sym_allow_control_characters)   { config->allow_control_characters = RTEST(val); }
     else if (key == sym_allow_invalid_escape)       { config->allow_invalid_escape = RTEST(val); }
     else if (key == sym_symbolize_names)            { config->symbolize_names = RTEST(val); }
     else if (key == sym_freeze)                     { config->freeze = RTEST(val); }
-    else if (key == sym_on_load)                    { parser_config_wb_write(self, &config->on_load_proc, RTEST(val) ? val : Qfalse); }
-    else if (key == sym_allow_duplicate_key)        { config->on_duplicate_key = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
+    else if (key == sym_on_load)                    {
+        if (RTEST(val) && !rb_obj_is_proc(val)) {
+            val = rb_check_funcall(val, rb_intern("to_proc"), 0, NULL);
+            if (val == Qundef || !rb_obj_is_proc(val)) {
+                rb_raise(rb_eTypeError, "on_load must be a Proc");
+            }
+        }
+        parser_config_wb_write(self, &config->on_load_proc, RTEST(val) ? val : Qfalse);
+    }
+    else if (key == sym_allow_duplicate_key)        { config->allow_duplicate_key = RTEST(val); }
     else if (key == sym_decimal_class)              {
         if (RTEST(val)) {
             if (rb_respond_to(val, i_try_convert)) {
@@ -2037,8 +2048,8 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
                     parser_config_wb_write(self, &config->decimal_class, rb_path_to_class(mod_path));
 
                     const char *method_name_beg = last_colon + 1;
-                    long before_len = method_name_beg - name_cstr;
-                    long len = RSTRING_LEN(name) - before_len;
+                    rb_len_t before_len = method_name_beg - name_cstr;
+                    rb_len_t len = RSTRING_LEN(name) - before_len;
                     VALUE method_name = rb_str_substr(name, before_len, len);
                     config->decimal_method_id = SYM2ID(rb_str_intern(method_name));
                 } else {
@@ -2048,7 +2059,7 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
             }
         }
     }
-    else if (args->strict) {
+    else {
         if (!args->unknown_keywords) {
             args->unknown_keywords = rb_obj_hide(rb_ary_new());
         }
@@ -2076,15 +2087,7 @@ static void parser_config_init(JSON_ParserConfig *config, VALUE opts, VALUE self
     // the provided keys than to check all possible keys.
     rb_hash_foreach(opts, parser_config_init_i, (VALUE)&args);
 
-    if (RB_UNLIKELY(args.unknown_keywords)) {
-        if (RARRAY_LEN(args.unknown_keywords) == 1) {
-            rb_raise(rb_eArgError, "unknown keyword: %" PRIsVALUE, RARRAY_AREF(args.unknown_keywords, 0));
-        }
-        else {
-            VALUE keywords = rb_ary_join(args.unknown_keywords, rb_utf8_str_new_cstr(", "));
-            rb_raise(rb_eArgError, "unknown keywords: %" PRIsVALUE, keywords);
-        }
-    }
+    raise_argument_error_on_unknown_keywords(args.unknown_keywords);
 }
 
 /*
@@ -2113,9 +2116,7 @@ static VALUE cParser_parse(JSON_ParserConfig *config, VALUE src)
     // Ensure the string isn't mutated under us.
     // The classic API to use is `rb_str_locktmp`, but then we'd
     // need to use `rb_protect` to make sure we always unlock.
-    if (Vsource == src) {
-        Vsource = rb_str_new_frozen(Vsource);
-    }
+    Vsource = rb_str_new_frozen(Vsource);
 
     VALUE rvalue_stack_buffer[RVALUE_STACK_INITIAL_CAPA];
     rvalue_stack value_stack = {
@@ -2139,7 +2140,7 @@ static VALUE cParser_parse(JSON_ParserConfig *config, VALUE src)
         .head = 1,
     };
 
-    long len;
+    rb_len_t len;
     const char *start;
 
     RSTRING_GETMEM(Vsource, start, len);
@@ -2163,6 +2164,12 @@ static VALUE cParser_parse(JSON_ParserConfig *config, VALUE src)
     // the rvalue stack.
     VALUE result = complete ? *rvalue_stack_peek(state->value_stack, 1) : Qundef;
 
+    if (complete) {
+        json_ensure_eof(state, config);
+    } else {
+        raise_eos_error("unexpected end of input", state);
+    }
+
     // This may be skipped in case of exception, but
     // it won't cause a leak.
     rvalue_stack_eagerly_release(value_stack_handle);
@@ -2171,12 +2178,6 @@ static VALUE cParser_parse(JSON_ParserConfig *config, VALUE src)
     RB_GC_GUARD(frame_stack_handle);
     RB_GC_GUARD(Vsource);
 
-    if (complete) {
-        json_ensure_eof(state, config);
-    } else {
-        raise_eos_error("unexpected end of input", state);
-    }
-
     return result;
 }
 
@@ -2458,7 +2459,7 @@ static VALUE cResumableParser_feed(VALUE self, VALUE str)
         rb_str_append(parser->buffer, str);
     }
 
-    long len;
+    rb_len_t len;
     const char *start;
     RSTRING_GETMEM(parser->buffer, start, len);
     parser->state.start = start;
@@ -2646,7 +2647,6 @@ static VALUE cResumableParser_clear(VALUE self)
     parser->state.name_cache.length = 0;
     parser->state.current_nesting = 0;
     parser->state.in_array = 1;
-    parser->state.emitted_deprecations = 0;
     parser->state.start = parser->state.cursor = parser->state.end = NULL;
     return self;
 }
@@ -2765,7 +2765,7 @@ static VALUE cResumableParser_rest(VALUE self)
 
     size_t offset = parser->state.cursor - parser->state.start;
     const char *ptr;
-    long len;
+    rb_len_t len;
     RSTRING_GETMEM(parser->buffer, ptr, len);
     return rb_utf8_str_new(ptr + offset, len - offset);
 }
@@ -2913,6 +2913,7 @@ void Init_parser(void)
     i_encode = rb_intern("encode");
     i_at_line = rb_intern("@line");
     i_at_column = rb_intern("@column");
+    i_at_json_path = rb_intern("@json_path");
 
     binary_encindex = rb_ascii8bit_encindex();
     utf8_encindex = rb_utf8_encindex();