+13 -2

lib/quickjs/compiler/compiler.ml

reviewed

··· 778 778 (* Compile class body *) 779 779 List.iter (fun elem -> 780 780 match elem with 781 781 - | Ast.Method_definition { key; value; kind; static; computed = _ } -> 781 781 + | Ast.Method_definition { key; value; kind; static; computed = _; decorators = _ } -> 782 782 emit_op comp Opcode.OP_dup; 783 783 if static then emit_op comp Opcode.OP_swap; 784 784 (match key.expr with ··· 793 793 emit_op comp Opcode.OP_define_method; 794 794 Bytecode.emit_u8 comp.builder method_flags; 795 795 Bytecode.update_stack comp.builder 2 0 796 796 - | Ast.Property_definition { key; value; static = _; computed = _ } -> 796 796 + | Ast.Property_definition { key; value; static = _; computed = _; decorators = _ } -> 797 797 + (match key.expr with 798 798 + | Ast.Literal (Ast.Lit_string s) -> emit_push_string comp s 799 799 + | _ -> compile_expr comp key); 800 800 + (match value with 801 801 + | Some v -> compile_expr comp v 802 802 + | None -> emit_op comp Opcode.OP_undefined); 803 803 + emit_op comp Opcode.OP_define_field; 804 804 + Bytecode.update_stack comp.builder 2 0 805 805 + | Ast.Accessor_definition { key; value; static = _; computed = _; decorators = _ } -> 806 806 + (* Auto-accessor fields: compile similarly to properties for now. 807 807 + TODO: Generate proper getter/setter pair with private backing field. *) 797 808 (match key.expr with 798 809 | Ast.Literal (Ast.Lit_string s) -> emit_push_string comp s 799 810 | _ -> compile_expr comp key);

+9

lib/quickjs/parser/ast.ml

reviewed

··· 186 186 kind : method_kind; 187 187 static : bool; 188 188 computed : bool; 189 189 + decorators : decorator list; 189 190 } 190 191 | Property_definition of { 191 192 key : expression; 192 193 value : expression option; 193 194 static : bool; 194 195 computed : bool; 196 196 + decorators : decorator list; 197 197 + } 198 198 + | Accessor_definition of { 199 199 + key : expression; 200 200 + value : expression option; 201 201 + static : bool; 202 202 + computed : bool; 203 203 + decorators : decorator list; 195 204 } 196 205 | Static_block of statement list 197 206

+9

lib/quickjs/parser/ast.mli

reviewed

··· 161 161 kind : method_kind; 162 162 static : bool; 163 163 computed : bool; 164 164 + decorators : decorator list; 164 165 } 165 166 | Property_definition of { 166 167 key : expression; 167 168 value : expression option; 168 169 static : bool; 169 170 computed : bool; 171 171 + decorators : decorator list; 172 172 + } 173 173 + | Accessor_definition of { 174 174 + key : expression; 175 175 + value : expression option; 176 176 + static : bool; 177 177 + computed : bool; 178 178 + decorators : decorator list; 170 179 } 171 180 | Static_block of statement list 172 181

+1 -1

lib/quickjs/parser/dune

reviewed

··· 1 1 (library 2 2 (name quickjs_parser) 3 3 (public_name ocaml-quickjs.parser) 4 4 - (libraries quickjs_core uutf) 4 4 + (libraries quickjs_core uutf uucp) 5 5 (flags (:standard -w -32-37-39-69)) ; Suppress various warnings during development 6 6 (preprocess no_preprocessing))

+557 -183

lib/quickjs/parser/lexer.ml

reviewed

··· 15 15 | Unterminated_regexp 16 16 | Unterminated_template 17 17 | Invalid_regexp_flag of char 18 18 + | Invalid_regexp of string 18 19 | Legacy_octal_in_strict_mode 20 20 + | Invalid_private_identifier 21 21 + | Numeric_followed_by_ident 19 22 20 23 exception Lexer_error of error * Source.loc 21 24 ··· 209 212 -> true 210 213 | _ -> false 211 214 215 215 + (* Characters that are NOT valid in identifiers despite their General_Category *) 216 216 + let is_unicode_invalid_id_char cp = 217 217 + (* Note: ZWNJ (200C) and ZWJ (200D) are format characters but ARE allowed in ID_Continue *) 218 218 + match cp with 219 219 + (* Format characters (Cf) that are not valid *) 220 220 + | 0x180E (* Mongolian Vowel Separator - explicitly not whitespace since Unicode 6.3 *) 221 221 + | 0x00AD (* Soft Hyphen *) 222 222 + | 0x200B (* Zero Width Space *) 223 223 + | 0x200E | 0x200F (* Left/Right-to-Left Mark *) 224 224 + | 0x2060 (* Word Joiner *) 225 225 + | 0x2061 | 0x2062 | 0x2063 | 0x2064 (* Invisible operators *) 226 226 + | 0x2066 | 0x2067 | 0x2068 | 0x2069 (* Bidi isolates *) 227 227 + | 0x206A | 0x206B | 0x206C | 0x206D | 0x206E | 0x206F (* Deprecated format chars *) 228 228 + | 0xFEFF (* BOM as format char when not at start - note: already handled as whitespace *) 229 229 + | 0xFFF9 | 0xFFFA | 0xFFFB (* Interlinear annotation anchors *) 230 230 + (* Pattern_Syntax characters that look like letters but aren't valid *) 231 231 + | 0x2E2F (* Vertical Tilde - in Pattern_Syntax despite being Lm *) 232 232 + -> true 233 233 + | _ -> false 234 234 + 212 235 let is_unicode_id_start cp = 213 236 (* Basic Latin letters are handled separately *) 214 237 if cp < 0x80 then false 238 238 + (* ZWNJ and ZWJ are NOT valid in ID_Start, only in ID_Continue *) 239 239 + else if cp = 0x200C || cp = 0x200D then false 240 240 + (* Reject characters that are not valid in identifiers *) 241 241 + else if is_unicode_invalid_id_char cp then false 215 242 (* Accept any non-ASCII, non-whitespace character as ID_Start *) 216 243 else not (is_unicode_whitespace_cp cp) 217 244 218 245 let is_unicode_id_continue cp = 219 246 (* ZWNJ and ZWJ are always allowed in ID_Continue *) 220 247 if cp = 0x200C || cp = 0x200D then true 248 248 + (* Reject invalid identifier characters (except ZWNJ/ZWJ handled above) *) 249 249 + else if is_unicode_invalid_id_char cp then false 221 250 (* Accept any non-ASCII, non-whitespace character as ID_Continue *) 222 251 else if cp >= 0x80 then not (is_unicode_whitespace_cp cp) 223 252 else false 224 253 254 254 + (* Validate code point is valid identifier start (ASCII or Unicode) *) 255 255 + let is_valid_id_start_cp cp = 256 256 + if cp < 0x80 then 257 257 + (* ASCII: a-z, A-Z, _, $ *) 258 258 + (cp >= 0x61 && cp <= 0x7A) || (* a-z *) 259 259 + (cp >= 0x41 && cp <= 0x5A) || (* A-Z *) 260 260 + cp = 0x5F || (* _ *) 261 261 + cp = 0x24 (* $ *) 262 262 + else 263 263 + is_unicode_id_start cp 264 264 + 265 265 + (* Validate code point is valid identifier continue (ASCII or Unicode) *) 266 266 + let is_valid_id_continue_cp cp = 267 267 + if cp < 0x80 then 268 268 + (* ASCII: a-z, A-Z, 0-9, _, $ *) 269 269 + (cp >= 0x61 && cp <= 0x7A) || (* a-z *) 270 270 + (cp >= 0x41 && cp <= 0x5A) || (* A-Z *) 271 271 + (cp >= 0x30 && cp <= 0x39) || (* 0-9 *) 272 272 + cp = 0x5F || (* _ *) 273 273 + cp = 0x24 (* $ *) 274 274 + else 275 275 + is_unicode_id_continue cp 276 276 + 225 277 let hex_value = function 226 278 | '0'..'9' as c -> Char.code c - Char.code '0' 227 279 | 'a'..'f' as c -> Char.code c - Char.code 'a' + 10 ··· 354 406 (* Validate numeric separator rules: 355 407 - Cannot have consecutive underscores 356 408 - Cannot start or end with underscore 357 357 - - Cannot have underscore adjacent to base prefix or decimal point *) 358 358 - let validate_numeric_separators lexer s = 409 409 + - Cannot have underscore adjacent to base prefix or decimal point 410 410 + ~check_exponent: whether to check for underscore adjacent to 'e'/'E' (only for decimals, not hex) *) 411 411 + let validate_numeric_separators ?(check_exponent=true) lexer s = 359 412 let len = String.length s in 360 413 for i = 0 to len - 1 do 361 414 if s.[i] = '_' then begin ··· 378 431 (* Check for underscore before decimal point *) 379 432 if i < len - 1 && s.[i+1] = '.' then 380 433 error lexer (Invalid_number "numeric separator cannot appear before decimal point"); 381 381 - (* Check for underscore adjacent to exponent *) 382 382 - if (i > 0 && (s.[i-1] = 'e' || s.[i-1] = 'E')) || 383 383 - (i < len - 1 && (s.[i+1] = 'e' || s.[i+1] = 'E')) then 434 434 + (* Check for underscore adjacent to exponent (only for decimal numbers, not hex where e/E are digits) *) 435 435 + if check_exponent && ((i > 0 && (s.[i-1] = 'e' || s.[i-1] = 'E')) || 436 436 + (i < len - 1 && (s.[i+1] = 'e' || s.[i+1] = 'E'))) then 384 437 error lexer (Invalid_number "numeric separator cannot appear adjacent to exponent"); 385 438 end 386 439 done 387 440 441 441 + (* Check that a numeric literal is not immediately followed by an identifier start *) 442 442 + let check_numeric_followed_by_ident lexer = 443 443 + let cursor = lexer.cursor in 444 444 + match Source.cursor_peek cursor with 445 445 + | Some c when is_identifier_start c -> error lexer Numeric_followed_by_ident 446 446 + | Some '\\' -> error lexer Numeric_followed_by_ident (* Unicode escape *) 447 447 + | _ -> () 448 448 + 388 449 let rec scan_number lexer = 389 450 let cursor = lexer.cursor in 390 451 Source.cursor_mark cursor; ··· 405 466 scan_binary_number lexer 406 467 | Some c when is_octal_digit c -> 407 468 scan_legacy_octal_number lexer 469 469 + | Some ('8' | '9') -> 470 470 + (* NonOctalDecimalIntegerLiteral: 08 or 09 - in non-strict mode *) 471 471 + if lexer.strict_mode then 472 472 + error lexer Legacy_octal_in_strict_mode; 473 473 + Source.cursor_skip_while cursor is_digit; 474 474 + let s = Source.cursor_slice cursor in 475 475 + Token.Number (float_of_string s, Token.Legacy_octal) 408 476 | Some '.' -> 409 477 Source.cursor_advance cursor; (* consume the '.' *) 410 478 scan_decimal_fraction lexer ··· 469 537 and scan_hex_number lexer = 470 538 let cursor = lexer.cursor in 471 539 Source.cursor_skip_while cursor (fun c -> is_hex_digit c || c = '_'); 540 540 + let s = Source.cursor_slice cursor in 541 541 + (* Validate there's at least one digit after "0x" or "0X" prefix *) 542 542 + if String.length s < 3 then 543 543 + error lexer (Invalid_number s); 472 544 match Source.cursor_peek cursor with 473 545 | Some 'n' -> 474 546 let s = Source.cursor_slice cursor in 475 475 - validate_numeric_separators lexer s; 547 547 + validate_numeric_separators ~check_exponent:false lexer s; 476 548 Source.cursor_advance cursor; 477 549 Token.BigInt s 478 550 | _ -> 479 551 let s = Source.cursor_slice cursor in 480 480 - validate_numeric_separators lexer s; 552 552 + validate_numeric_separators ~check_exponent:false lexer s; 481 553 let s = String.concat "" (String.split_on_char '_' s) in 482 554 let hex_part = String.sub s 2 (String.length s - 2) in 483 555 Token.Number (float_of_int (int_of_string ("0x" ^ hex_part)), Token.Hex) ··· 485 557 and scan_octal_number lexer = 486 558 let cursor = lexer.cursor in 487 559 Source.cursor_skip_while cursor (fun c -> is_octal_digit c || c = '_'); 560 560 + let s = Source.cursor_slice cursor in 561 561 + (* Validate there's at least one digit after "0o" or "0O" prefix *) 562 562 + if String.length s < 3 then 563 563 + error lexer (Invalid_number s); 488 564 match Source.cursor_peek cursor with 489 565 | Some 'n' -> 490 566 let s = Source.cursor_slice cursor in ··· 501 577 and scan_binary_number lexer = 502 578 let cursor = lexer.cursor in 503 579 Source.cursor_skip_while cursor (fun c -> is_binary_digit c || c = '_'); 580 580 + let s = Source.cursor_slice cursor in 581 581 + (* Validate there's at least one digit after "0b" or "0B" prefix *) 582 582 + if String.length s < 3 then 583 583 + error lexer (Invalid_number s); 504 584 match Source.cursor_peek cursor with 505 585 | Some 'n' -> 506 586 let s = Source.cursor_slice cursor in ··· 518 598 let cursor = lexer.cursor in 519 599 if lexer.strict_mode then 520 600 error lexer Legacy_octal_in_strict_mode; 601 601 + (* Scan octal digits first *) 521 602 Source.cursor_skip_while cursor is_octal_digit; 522 522 - let s = Source.cursor_slice cursor in 523 523 - Token.Number (float_of_int (int_of_string ("0o" ^ String.sub s 1 (String.length s - 1))), Token.Legacy_octal) 603 603 + (* Check if followed by 8 or 9 (NonOctalDecimalIntegerLiteral) *) 604 604 + match Source.cursor_peek cursor with 605 605 + | Some ('8' | '9') -> 606 606 + (* Continue scanning as decimal number - this is a NonOctalDecimalIntegerLiteral *) 607 607 + Source.cursor_skip_while cursor is_digit; 608 608 + let s = Source.cursor_slice cursor in 609 609 + (* Parse the whole thing as a decimal, stripping leading zeros *) 610 610 + Token.Number (float_of_string s, Token.Legacy_octal) 611 611 + | _ -> 612 612 + let s = Source.cursor_slice cursor in 613 613 + Token.Number (float_of_int (int_of_string ("0o" ^ String.sub s 1 (String.length s - 1))), Token.Legacy_octal) 614 614 + 615 615 + (* Helper: add UTF-8 bytes to buffer for a code point. 616 616 + Defined here so it can be used by scan_escape_sequence_to_buffer. *) 617 617 + and add_utf8_to_buffer buf cp = 618 618 + if cp <= 0x7F then 619 619 + Buffer.add_char buf (Char.chr cp) 620 620 + else if cp <= 0x7FF then begin 621 621 + Buffer.add_char buf (Char.chr (0xC0 lor (cp lsr 6))); 622 622 + Buffer.add_char buf (Char.chr (0x80 lor (cp land 0x3F))) 623 623 + end else if cp <= 0xFFFF then begin 624 624 + Buffer.add_char buf (Char.chr (0xE0 lor (cp lsr 12))); 625 625 + Buffer.add_char buf (Char.chr (0x80 lor ((cp lsr 6) land 0x3F))); 626 626 + Buffer.add_char buf (Char.chr (0x80 lor (cp land 0x3F))) 627 627 + end else begin 628 628 + Buffer.add_char buf (Char.chr (0xF0 lor (cp lsr 18))); 629 629 + Buffer.add_char buf (Char.chr (0x80 lor ((cp lsr 12) land 0x3F))); 630 630 + Buffer.add_char buf (Char.chr (0x80 lor ((cp lsr 6) land 0x3F))); 631 631 + Buffer.add_char buf (Char.chr (0x80 lor (cp land 0x3F))) 632 632 + end 524 633 525 634 (* Scan string literal *) 526 635 and scan_string lexer quote = ··· 535 644 Buffer.contents buf 536 645 | Some '\\' -> 537 646 Source.cursor_advance cursor; 538 538 - Buffer.add_char buf (scan_escape_sequence lexer); 647 647 + scan_escape_sequence_to_buffer lexer buf ~in_template:false; 539 648 loop () 540 649 | Some c when is_line_terminator c -> 541 650 error lexer Unterminated_string ··· 548 657 let kind = if quote = '\'' then Token.Single_quoted else Token.Double_quoted in 549 658 Token.String (s, kind) 550 659 551 551 - and scan_escape_sequence lexer = 660 660 + and scan_escape_sequence ?(in_template=false) lexer = 552 661 let cursor = lexer.cursor in 553 662 match Source.cursor_peek cursor with 554 663 | None -> error lexer Unexpected_eof ··· 559 668 | Some 'f' -> Source.cursor_advance cursor; '\x0c' 560 669 | Some 'v' -> Source.cursor_advance cursor; '\x0b' 561 670 | Some c when c >= '0' && c <= '7' -> 562 562 - (* Legacy octal escape sequence - allowed in non-strict mode *) 563 563 - if lexer.strict_mode && c <> '0' then 564 564 - error lexer Legacy_octal_in_strict_mode; 565 565 - let value = ref (Char.code c - Char.code '0') in 566 566 - Source.cursor_advance cursor; 567 567 - (* Check for more octal digits *) 568 568 - let first_digit = Char.code c - Char.code '0' in 569 569 - (match Source.cursor_peek cursor with 570 570 - | Some c2 when c2 >= '0' && c2 <= '7' -> 571 571 - if lexer.strict_mode then 572 572 - error lexer Legacy_octal_in_strict_mode; 573 573 - value := !value * 8 + (Char.code c2 - Char.code '0'); 574 574 - Source.cursor_advance cursor; 575 575 - (* Check for third digit - only if first digit is 0-3 *) 576 576 - if first_digit <= 3 then begin 577 577 - match Source.cursor_peek cursor with 578 578 - | Some c3 when c3 >= '0' && c3 <= '7' -> 579 579 - value := !value * 8 + (Char.code c3 - Char.code '0'); 580 580 - Source.cursor_advance cursor 581 581 - | _ -> () 582 582 - end 583 583 - | Some c2 when is_digit c2 -> 584 584 - (* \0 followed by non-octal digit 8 or 9 - just the \0, digit stays *) 585 585 - () 586 586 - | _ -> ()); 587 587 - Char.chr (!value land 0xFF) 671 671 + (* Legacy octal escape sequence - never allowed in templates, only in strings in non-strict mode *) 672 672 + if in_template then begin 673 673 + (* Template literals: only \0 followed by non-digit is allowed *) 674 674 + if c <> '0' then 675 675 + error lexer Legacy_octal_in_strict_mode; 676 676 + Source.cursor_advance cursor; 677 677 + (match Source.cursor_peek cursor with 678 678 + | Some c2 when is_digit c2 -> 679 679 + error lexer Legacy_octal_in_strict_mode 680 680 + | _ -> ()); 681 681 + '\000' 682 682 + end else begin 683 683 + if lexer.strict_mode && c <> '0' then 684 684 + error lexer Legacy_octal_in_strict_mode; 685 685 + let value = ref (Char.code c - Char.code '0') in 686 686 + Source.cursor_advance cursor; 687 687 + (* Check for more octal digits *) 688 688 + let first_digit = Char.code c - Char.code '0' in 689 689 + (match Source.cursor_peek cursor with 690 690 + | Some c2 when c2 >= '0' && c2 <= '7' -> 691 691 + if lexer.strict_mode then 692 692 + error lexer Legacy_octal_in_strict_mode; 693 693 + value := !value * 8 + (Char.code c2 - Char.code '0'); 694 694 + Source.cursor_advance cursor; 695 695 + (* Check for third digit - only if first digit is 0-3 *) 696 696 + if first_digit <= 3 then begin 697 697 + match Source.cursor_peek cursor with 698 698 + | Some c3 when c3 >= '0' && c3 <= '7' -> 699 699 + value := !value * 8 + (Char.code c3 - Char.code '0'); 700 700 + Source.cursor_advance cursor 701 701 + | _ -> () 702 702 + end 703 703 + | Some c2 when is_digit c2 -> 704 704 + (* \0 followed by non-octal digit 8 or 9 is legacy octal escape sequence 705 705 + and not allowed in strict mode (per spec: 0 [lookahead ∉ DecimalDigit]) *) 706 706 + if lexer.strict_mode then 707 707 + error lexer Legacy_octal_in_strict_mode 708 708 + | _ -> ()); 709 709 + Char.chr (!value land 0xFF) 710 710 + end 588 711 | Some 'x' -> 589 712 Source.cursor_advance cursor; 590 713 scan_hex_escape lexer 2 ··· 604 727 Source.cursor_advance cursor; 605 728 lexer.newline_before <- true; 606 729 ' ' 730 730 + | Some ('8' | '9') when lexer.strict_mode || in_template -> 731 731 + (* NonOctalDecimalEscapeSequence (\8, \9) not allowed in strict mode or templates *) 732 732 + error lexer Legacy_octal_in_strict_mode 607 733 | Some c -> 608 734 Source.cursor_advance cursor; 609 735 c 610 736 737 737 + (* Scan escape sequence and add result to buffer. 738 738 + Unlike scan_escape_sequence (which returns a char), this properly handles 739 739 + unicode escapes that produce code points > 0xFF by encoding them as UTF-8. *) 740 740 + and scan_escape_sequence_to_buffer lexer buf ~in_template = 741 741 + let cursor = lexer.cursor in 742 742 + match Source.cursor_peek cursor with 743 743 + | None -> error lexer Unexpected_eof 744 744 + | Some 'n' -> Source.cursor_advance cursor; Buffer.add_char buf '\n' 745 745 + | Some 'r' -> Source.cursor_advance cursor; Buffer.add_char buf '\r' 746 746 + | Some 't' -> Source.cursor_advance cursor; Buffer.add_char buf '\t' 747 747 + | Some 'b' -> Source.cursor_advance cursor; Buffer.add_char buf '\b' 748 748 + | Some 'f' -> Source.cursor_advance cursor; Buffer.add_char buf '\x0c' 749 749 + | Some 'v' -> Source.cursor_advance cursor; Buffer.add_char buf '\x0b' 750 750 + | Some c when c >= '0' && c <= '7' -> 751 751 + if in_template then begin 752 752 + if c <> '0' then error lexer Legacy_octal_in_strict_mode; 753 753 + Source.cursor_advance cursor; 754 754 + (match Source.cursor_peek cursor with 755 755 + | Some c2 when is_digit c2 -> error lexer Legacy_octal_in_strict_mode 756 756 + | _ -> ()); 757 757 + Buffer.add_char buf '\000' 758 758 + end else begin 759 759 + if lexer.strict_mode && c <> '0' then error lexer Legacy_octal_in_strict_mode; 760 760 + if c = '0' then begin 761 761 + Source.cursor_advance cursor; 762 762 + match Source.cursor_peek cursor with 763 763 + | Some c2 when c2 >= '0' && c2 <= '9' -> 764 764 + if lexer.strict_mode then error lexer Legacy_octal_in_strict_mode; 765 765 + (* Legacy octal: \0X *) 766 766 + let value = ref (Char.code c - Char.code '0') in 767 767 + while match Source.cursor_peek cursor with Some d when d >= '0' && d <= '7' -> true | _ -> false do 768 768 + value := !value * 8 + (Char.code (Option.get (Source.cursor_peek cursor)) - Char.code '0'); 769 769 + Source.cursor_advance cursor 770 770 + done; 771 771 + Buffer.add_char buf (Char.chr (!value land 0xFF)) 772 772 + | _ -> Buffer.add_char buf '\000' 773 773 + end else begin 774 774 + if lexer.strict_mode then error lexer Legacy_octal_in_strict_mode; 775 775 + let value = ref (Char.code c - Char.code '0') in 776 776 + Source.cursor_advance cursor; 777 777 + while match Source.cursor_peek cursor with Some d when d >= '0' && d <= '7' -> true | _ -> false do 778 778 + value := !value * 8 + (Char.code (Option.get (Source.cursor_peek cursor)) - Char.code '0'); 779 779 + Source.cursor_advance cursor 780 780 + done; 781 781 + Buffer.add_char buf (Char.chr (!value land 0xFF)) 782 782 + end 783 783 + end 784 784 + | Some 'x' -> 785 785 + Source.cursor_advance cursor; 786 786 + let c = scan_hex_escape lexer 2 in 787 787 + Buffer.add_char buf c 788 788 + | Some 'u' -> 789 789 + Source.cursor_advance cursor; 790 790 + let cp = scan_unicode_escape_codepoint lexer in 791 791 + add_utf8_to_buffer buf cp 792 792 + | Some '\r' -> 793 793 + Source.cursor_advance cursor; 794 794 + lexer.newline_before <- true; 795 795 + (match Source.cursor_peek cursor with 796 796 + | Some '\n' -> Source.cursor_advance cursor 797 797 + | _ -> ()) 798 798 + (* Line continuation - add nothing to buffer *) 799 799 + | Some '\n' -> 800 800 + Source.cursor_advance cursor; 801 801 + lexer.newline_before <- true 802 802 + (* Line continuation - add nothing to buffer *) 803 803 + | Some ('8' | '9') when lexer.strict_mode || in_template -> 804 804 + error lexer Legacy_octal_in_strict_mode 805 805 + | Some c -> 806 806 + Source.cursor_advance cursor; 807 807 + Buffer.add_char buf c 808 808 + 809 809 + (* Scan \uXXXX or \u{XXXX} and return the code point value *) 810 810 + and scan_unicode_escape_codepoint lexer = 811 811 + let cursor = lexer.cursor in 812 812 + match Source.cursor_peek cursor with 813 813 + | Some '{' -> 814 814 + Source.cursor_advance cursor; 815 815 + let value = ref 0 in 816 816 + let rec loop () = 817 817 + match Source.cursor_peek cursor with 818 818 + | Some '}' -> 819 819 + Source.cursor_advance cursor; 820 820 + if !value > 0x10FFFF then 821 821 + error lexer (Invalid_unicode_escape "code point out of range"); 822 822 + !value 823 823 + | Some c when is_hex_digit c -> 824 824 + value := !value * 16 + hex_value c; 825 825 + Source.cursor_advance cursor; 826 826 + loop () 827 827 + | _ -> error lexer (Invalid_unicode_escape "expected hex digit or '}'") 828 828 + in 829 829 + loop () 830 830 + | _ -> 831 831 + (* \uXXXX - exactly 4 hex digits *) 832 832 + let value = ref 0 in 833 833 + for _ = 1 to 4 do 834 834 + match Source.cursor_peek cursor with 835 835 + | Some c when is_hex_digit c -> 836 836 + value := !value * 16 + hex_value c; 837 837 + Source.cursor_advance cursor 838 838 + | _ -> error lexer (Invalid_unicode_escape "incomplete") 839 839 + done; 840 840 + !value 841 841 + 611 842 and scan_hex_escape lexer n = 612 843 let cursor = lexer.cursor in 613 844 let value = ref 0 in ··· 645 876 (* \uXXXX *) 646 877 scan_hex_escape lexer 4 647 878 648 648 - (* Helper: add UTF-8 bytes to buffer for a code point *) 649 649 - let add_utf8_to_buffer buf cp = 650 650 - if cp <= 0x7F then 651 651 - Buffer.add_char buf (Char.chr cp) 652 652 - else if cp <= 0x7FF then begin 653 653 - Buffer.add_char buf (Char.chr (0xC0 lor (cp lsr 6))); 654 654 - Buffer.add_char buf (Char.chr (0x80 lor (cp land 0x3F))) 655 655 - end else if cp <= 0xFFFF then begin 656 656 - Buffer.add_char buf (Char.chr (0xE0 lor (cp lsr 12))); 657 657 - Buffer.add_char buf (Char.chr (0x80 lor ((cp lsr 6) land 0x3F))); 658 658 - Buffer.add_char buf (Char.chr (0x80 lor (cp land 0x3F))) 659 659 - end else begin 660 660 - Buffer.add_char buf (Char.chr (0xF0 lor (cp lsr 18))); 661 661 - Buffer.add_char buf (Char.chr (0x80 lor ((cp lsr 12) land 0x3F))); 662 662 - Buffer.add_char buf (Char.chr (0x80 lor ((cp lsr 6) land 0x3F))); 663 663 - Buffer.add_char buf (Char.chr (0x80 lor (cp land 0x3F))) 664 664 - end 879 879 + (* Helper to parse \uXXXX or \u{XXXX} and return the code point, advancing cursor past 'u' *) 880 880 + let parse_unicode_escape_value lexer = 881 881 + let cursor = lexer.cursor in 882 882 + match Source.cursor_peek cursor with 883 883 + | Some '{' -> 884 884 + (* \u{XXXX} form *) 885 885 + Source.cursor_advance cursor; 886 886 + let value = ref 0 in 887 887 + let rec scan_hex () = 888 888 + match Source.cursor_peek cursor with 889 889 + | Some '}' -> Source.cursor_advance cursor 890 890 + | Some c when is_hex_digit c -> 891 891 + Source.cursor_advance cursor; 892 892 + value := !value * 16 + hex_value c; 893 893 + scan_hex () 894 894 + | _ -> error lexer (Invalid_unicode_escape "incomplete") 895 895 + in 896 896 + scan_hex (); 897 897 + !value 898 898 + | _ -> 899 899 + (* \uXXXX form *) 900 900 + let d1 = match Source.cursor_peek cursor with 901 901 + | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 902 902 + | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 903 903 + in 904 904 + let d2 = match Source.cursor_peek cursor with 905 905 + | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 906 906 + | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 907 907 + in 908 908 + let d3 = match Source.cursor_peek cursor with 909 909 + | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 910 910 + | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 911 911 + in 912 912 + let d4 = match Source.cursor_peek cursor with 913 913 + | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 914 914 + | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 915 915 + in 916 916 + (d1 lsl 12) lor (d2 lsl 8) lor (d3 lsl 4) lor d4 665 917 666 918 (* Scan identifier, handling Unicode escapes *) 667 919 let scan_identifier lexer = 668 920 let cursor = lexer.cursor in 669 921 let buf = Buffer.create 16 in 670 922 let has_escape = ref false in 923 923 + let is_first = ref true in 671 924 let rec loop () = 672 925 match Source.cursor_peek cursor with 673 926 | Some c when is_identifier_continue c -> 674 927 Source.cursor_advance cursor; 675 928 Buffer.add_char buf c; 929 929 + is_first := false; 676 930 loop () 677 931 | Some c when Char.code c >= 0x80 -> 678 932 (* Check for Unicode character *) ··· 682 936 if is_unicode_id_continue cp then begin 683 937 Source.cursor_advance_n cursor byte_len; 684 938 add_utf8_to_buffer buf cp; 939 939 + is_first := false; 685 940 loop () 686 941 end 687 942 | None -> ()) ··· 691 946 (match Source.cursor_peek cursor with 692 947 | Some 'u' -> 693 948 Source.cursor_advance cursor; 949 949 + let value = parse_unicode_escape_value lexer in 950 950 + (* Validate the code point is valid for identifier position *) 951 951 + if !is_first then begin 952 952 + if not (is_valid_id_start_cp value) then 953 953 + error lexer (Invalid_unicode_escape "not a valid identifier start character") 954 954 + end else begin 955 955 + if not (is_valid_id_continue_cp value) then 956 956 + error lexer (Invalid_unicode_escape "not a valid identifier character") 957 957 + end; 694 958 has_escape := true; 695 695 - (match Source.cursor_peek cursor with 696 696 - | Some '{' -> 697 697 - (* \u{XXXX} form *) 698 698 - Source.cursor_advance cursor; 699 699 - let value = ref 0 in 700 700 - let rec scan_hex () = 701 701 - match Source.cursor_peek cursor with 702 702 - | Some '}' -> Source.cursor_advance cursor 703 703 - | Some c when is_hex_digit c -> 704 704 - Source.cursor_advance cursor; 705 705 - value := !value * 16 + hex_value c; 706 706 - scan_hex () 707 707 - | _ -> error lexer (Invalid_unicode_escape "incomplete") 708 708 - in 709 709 - scan_hex (); 710 710 - (* Convert code point to character(s) *) 711 711 - if !value <= 0x7F then 712 712 - Buffer.add_char buf (Char.chr !value) 713 713 - else if !value <= 0x7FF then begin 714 714 - Buffer.add_char buf (Char.chr (0xC0 lor (!value lsr 6))); 715 715 - Buffer.add_char buf (Char.chr (0x80 lor (!value land 0x3F))) 716 716 - end else if !value <= 0xFFFF then begin 717 717 - Buffer.add_char buf (Char.chr (0xE0 lor (!value lsr 12))); 718 718 - Buffer.add_char buf (Char.chr (0x80 lor ((!value lsr 6) land 0x3F))); 719 719 - Buffer.add_char buf (Char.chr (0x80 lor (!value land 0x3F))) 720 720 - end else begin 721 721 - Buffer.add_char buf (Char.chr (0xF0 lor (!value lsr 18))); 722 722 - Buffer.add_char buf (Char.chr (0x80 lor ((!value lsr 12) land 0x3F))); 723 723 - Buffer.add_char buf (Char.chr (0x80 lor ((!value lsr 6) land 0x3F))); 724 724 - Buffer.add_char buf (Char.chr (0x80 lor (!value land 0x3F))) 725 725 - end; 726 726 - loop () 727 727 - | _ -> 728 728 - (* \uXXXX form *) 729 729 - let d1 = match Source.cursor_peek cursor with 730 730 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 731 731 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 732 732 - in 733 733 - let d2 = match Source.cursor_peek cursor with 734 734 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 735 735 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 736 736 - in 737 737 - let d3 = match Source.cursor_peek cursor with 738 738 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 739 739 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 740 740 - in 741 741 - let d4 = match Source.cursor_peek cursor with 742 742 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 743 743 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 744 744 - in 745 745 - let value = (d1 lsl 12) lor (d2 lsl 8) lor (d3 lsl 4) lor d4 in 746 746 - if value <= 0x7F then 747 747 - Buffer.add_char buf (Char.chr value) 748 748 - else if value <= 0x7FF then begin 749 749 - Buffer.add_char buf (Char.chr (0xC0 lor (value lsr 6))); 750 750 - Buffer.add_char buf (Char.chr (0x80 lor (value land 0x3F))) 751 751 - end else begin 752 752 - Buffer.add_char buf (Char.chr (0xE0 lor (value lsr 12))); 753 753 - Buffer.add_char buf (Char.chr (0x80 lor ((value lsr 6) land 0x3F))); 754 754 - Buffer.add_char buf (Char.chr (0x80 lor (value land 0x3F))) 755 755 - end; 756 756 - loop ()) 959 959 + add_utf8_to_buffer buf value; 960 960 + is_first := false; 961 961 + loop () 757 962 | _ -> error lexer (Invalid_escape_sequence "\\")) 758 963 | _ -> () 759 964 in ··· 765 970 | Some kw -> Token.Keyword kw 766 971 | None -> Token.Identifier s 767 972 else 768 768 - Token.Identifier s 973 973 + Token.Escaped_identifier s 769 974 770 975 (* Scan Unicode identifier - starts with a Unicode ID_Start character *) 771 976 let scan_unicode_identifier lexer = ··· 794 999 (match Source.cursor_peek cursor with 795 1000 | Some 'u' -> 796 1001 Source.cursor_advance cursor; 797 797 - (match Source.cursor_peek cursor with 798 798 - | Some '{' -> 799 799 - (* \u{XXXX} form *) 800 800 - Source.cursor_advance cursor; 801 801 - let value = ref 0 in 802 802 - let rec scan_hex () = 803 803 - match Source.cursor_peek cursor with 804 804 - | Some '}' -> Source.cursor_advance cursor 805 805 - | Some c when is_hex_digit c -> 806 806 - Source.cursor_advance cursor; 807 807 - value := !value * 16 + hex_value c; 808 808 - scan_hex () 809 809 - | _ -> error lexer (Invalid_unicode_escape "incomplete") 810 810 - in 811 811 - scan_hex (); 812 812 - add_utf8_to_buffer buf !value; 813 813 - loop () 814 814 - | _ -> 815 815 - (* \uXXXX form *) 816 816 - let d1 = match Source.cursor_peek cursor with 817 817 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 818 818 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 819 819 - in 820 820 - let d2 = match Source.cursor_peek cursor with 821 821 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 822 822 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 823 823 - in 824 824 - let d3 = match Source.cursor_peek cursor with 825 825 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 826 826 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 827 827 - in 828 828 - let d4 = match Source.cursor_peek cursor with 829 829 - | Some c when is_hex_digit c -> Source.cursor_advance cursor; hex_value c 830 830 - | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 831 831 - in 832 832 - let value = (d1 lsl 12) lor (d2 lsl 8) lor (d3 lsl 4) lor d4 in 833 833 - add_utf8_to_buffer buf value; 834 834 - loop ()) 1002 1002 + let value = parse_unicode_escape_value lexer in 1003 1003 + (* Validate continue character (first char was already consumed) *) 1004 1004 + if not (is_valid_id_continue_cp value) then 1005 1005 + error lexer (Invalid_unicode_escape "not a valid identifier character"); 1006 1006 + add_utf8_to_buffer buf value; 1007 1007 + loop () 835 1008 | _ -> error lexer (Invalid_escape_sequence "\\")) 836 1009 | _ -> () 837 1010 in ··· 845 1018 let s = Buffer.contents buf in 846 1019 Token.Identifier s 847 1020 848 848 - (* Scan template literal *) 1021 1021 + (* Scan template escape sequence for raw value, adding to raw buffer *) 1022 1022 + let rec scan_template_escape_raw raw_buf lexer = 1023 1023 + let cursor = lexer.cursor in 1024 1024 + match Source.cursor_peek cursor with 1025 1025 + | None -> () 1026 1026 + | Some c when c >= '0' && c <= '9' -> 1027 1027 + Buffer.add_char raw_buf c; 1028 1028 + Source.cursor_advance cursor 1029 1029 + | Some 'x' -> 1030 1030 + Buffer.add_char raw_buf 'x'; 1031 1031 + Source.cursor_advance cursor; 1032 1032 + (* Read up to 2 hex digits for raw *) 1033 1033 + for _ = 1 to 2 do 1034 1034 + match Source.cursor_peek cursor with 1035 1035 + | Some c when is_hex_digit c -> 1036 1036 + Buffer.add_char raw_buf c; 1037 1037 + Source.cursor_advance cursor 1038 1038 + | _ -> () 1039 1039 + done 1040 1040 + | Some 'u' -> 1041 1041 + Buffer.add_char raw_buf 'u'; 1042 1042 + Source.cursor_advance cursor; 1043 1043 + (* Read unicode escape for raw *) 1044 1044 + (match Source.cursor_peek cursor with 1045 1045 + | Some '{' -> 1046 1046 + Buffer.add_char raw_buf '{'; 1047 1047 + Source.cursor_advance cursor; 1048 1048 + (* Read until } or non-hex *) 1049 1049 + let rec read_braced () = 1050 1050 + match Source.cursor_peek cursor with 1051 1051 + | Some '}' -> 1052 1052 + Buffer.add_char raw_buf '}'; 1053 1053 + Source.cursor_advance cursor 1054 1054 + | Some c when is_hex_digit c -> 1055 1055 + Buffer.add_char raw_buf c; 1056 1056 + Source.cursor_advance cursor; 1057 1057 + read_braced () 1058 1058 + | _ -> () (* Invalid, but we've captured what we can *) 1059 1059 + in 1060 1060 + read_braced () 1061 1061 + | _ -> 1062 1062 + (* Read up to 4 hex digits *) 1063 1063 + for _ = 1 to 4 do 1064 1064 + match Source.cursor_peek cursor with 1065 1065 + | Some c when is_hex_digit c -> 1066 1066 + Buffer.add_char raw_buf c; 1067 1067 + Source.cursor_advance cursor 1068 1068 + | _ -> () 1069 1069 + done) 1070 1070 + | Some c -> 1071 1071 + Buffer.add_char raw_buf c; 1072 1072 + Source.cursor_advance cursor 1073 1073 + 1074 1074 + (* Try to scan a cooked escape sequence, returns None if invalid *) 1075 1075 + let scan_template_escape_cooked lexer = 1076 1076 + let cursor = lexer.cursor in 1077 1077 + match Source.cursor_peek cursor with 1078 1078 + | None -> None 1079 1079 + | Some 'n' -> Source.cursor_advance cursor; Some '\n' 1080 1080 + | Some 'r' -> Source.cursor_advance cursor; Some '\r' 1081 1081 + | Some 't' -> Source.cursor_advance cursor; Some '\t' 1082 1082 + | Some 'b' -> Source.cursor_advance cursor; Some '\b' 1083 1083 + | Some 'f' -> Source.cursor_advance cursor; Some '\x0c' 1084 1084 + | Some 'v' -> Source.cursor_advance cursor; Some '\x0b' 1085 1085 + | Some c when c >= '0' && c <= '9' -> 1086 1086 + if c = '0' then begin 1087 1087 + Source.cursor_advance cursor; 1088 1088 + match Source.cursor_peek cursor with 1089 1089 + | Some c2 when is_digit c2 -> None (* \0 followed by digit - invalid *) 1090 1090 + | _ -> Some '\000' 1091 1091 + end else 1092 1092 + (Source.cursor_advance cursor; None) (* \1-\9 invalid in templates *) 1093 1093 + | Some 'x' -> 1094 1094 + Source.cursor_advance cursor; 1095 1095 + (try Some (scan_hex_escape lexer 2) with Lexer_error _ -> None) 1096 1096 + | Some 'u' -> 1097 1097 + Source.cursor_advance cursor; 1098 1098 + (try Some (scan_unicode_escape lexer) with Lexer_error _ -> None) 1099 1099 + | Some c -> 1100 1100 + Source.cursor_advance cursor; 1101 1101 + Some c 1102 1102 + 1103 1103 + (* Scan template literal - returns token with both raw and cooked values *) 849 1104 let scan_template lexer ~is_head = 850 1105 let cursor = lexer.cursor in 851 851 - let buf = Buffer.create 64 in 1106 1106 + let raw_buf = Buffer.create 64 in 1107 1107 + let cooked_buf = Buffer.create 64 in 1108 1108 + let has_invalid_escape = ref false in 852 1109 let rec loop () = 853 1110 match Source.cursor_peek cursor with 854 1111 | None -> error lexer Unterminated_template 855 1112 | Some '`' -> 856 1113 Source.cursor_advance cursor; 857 857 - let s = Buffer.contents buf in 858 858 - if is_head then Token.Template (Token.Template_no_sub s) 859 859 - else Token.Template (Token.Template_tail s) 1114 1114 + let raw = Buffer.contents raw_buf in 1115 1115 + let cooked = if !has_invalid_escape then None else Some (Buffer.contents cooked_buf) in 1116 1116 + if is_head then Token.Template (Token.Template_no_sub { raw; cooked }) 1117 1117 + else Token.Template (Token.Template_tail { raw; cooked }) 860 1118 | Some '$' -> 861 1119 (match Source.cursor_peek_n cursor 2 with 862 1120 | Some "${" -> 863 1121 Source.cursor_advance_n cursor 2; 864 864 - let s = Buffer.contents buf in 865 865 - if is_head then Token.Template (Token.Template_head s) 866 866 - else Token.Template (Token.Template_middle s) 1122 1122 + let raw = Buffer.contents raw_buf in 1123 1123 + let cooked = if !has_invalid_escape then None else Some (Buffer.contents cooked_buf) in 1124 1124 + if is_head then Token.Template (Token.Template_head { raw; cooked }) 1125 1125 + else Token.Template (Token.Template_middle { raw; cooked }) 867 1126 | _ -> 868 1127 Source.cursor_advance cursor; 869 869 - Buffer.add_char buf '$'; 1128 1128 + Buffer.add_char raw_buf '$'; 1129 1129 + Buffer.add_char cooked_buf '$'; 870 1130 loop ()) 871 1131 | Some '\\' -> 872 1132 Source.cursor_advance cursor; 1133 1133 + Buffer.add_char raw_buf '\\'; 873 1134 (* Template literals allow line continuations *) 874 1135 (match Source.cursor_peek cursor with 875 1136 | Some '\r' -> 1137 1137 + Buffer.add_char raw_buf '\r'; 876 1138 Source.cursor_advance cursor; 877 1139 (match Source.cursor_peek cursor with 878 878 - | Some '\n' -> Source.cursor_advance cursor 1140 1140 + | Some '\n' -> 1141 1141 + Buffer.add_char raw_buf '\n'; 1142 1142 + Source.cursor_advance cursor 879 1143 | _ -> ()); 880 1144 lexer.newline_before <- true; 881 1145 loop () 882 1146 | Some '\n' -> 1147 1147 + Buffer.add_char raw_buf '\n'; 883 1148 Source.cursor_advance cursor; 884 1149 lexer.newline_before <- true; 885 1150 loop () 886 1151 | _ -> 887 887 - Buffer.add_char buf (scan_escape_sequence lexer); 888 888 - loop ()) 1152 1152 + (* Save cursor position before parsing escape *) 1153 1153 + let saved_cursor = Source.cursor_save cursor in 1154 1154 + let saved_newline = lexer.newline_before in 1155 1155 + (* Try to parse cooked value *) 1156 1156 + match scan_template_escape_cooked lexer with 1157 1157 + | Some c -> 1158 1158 + (* Valid escape - need to get raw text from saved to current *) 1159 1159 + Source.cursor_restore cursor saved_cursor; 1160 1160 + scan_template_escape_raw raw_buf lexer; 1161 1161 + Buffer.add_char cooked_buf c; 1162 1162 + loop () 1163 1163 + | None -> 1164 1164 + (* Invalid escape - just capture raw, mark cooked invalid *) 1165 1165 + Source.cursor_restore cursor saved_cursor; 1166 1166 + lexer.newline_before <- saved_newline; 1167 1167 + scan_template_escape_raw raw_buf lexer; 1168 1168 + has_invalid_escape := true; 1169 1169 + loop ()) 889 1170 | Some c when is_line_terminator c -> 890 890 - Buffer.add_char buf c; 1171 1171 + Buffer.add_char raw_buf c; 1172 1172 + Buffer.add_char cooked_buf c; 891 1173 Source.cursor_advance cursor; 892 1174 lexer.newline_before <- true; 893 1175 loop () 894 1176 | Some c -> 895 895 - Buffer.add_char buf c; 1177 1177 + Buffer.add_char raw_buf c; 1178 1178 + Buffer.add_char cooked_buf c; 896 1179 Source.cursor_advance cursor; 897 1180 loop () 898 1181 in ··· 915 1198 Source.cursor_advance cursor; 916 1199 (match Source.cursor_peek cursor with 917 1200 | None -> error lexer Unterminated_regexp 1201 1201 + | Some c when is_line_terminator c -> 1202 1202 + (* Backslash cannot escape a line terminator *) 1203 1203 + error lexer Unterminated_regexp 918 1204 | Some c -> 919 1205 Buffer.add_char pattern c; 920 1206 Source.cursor_advance cursor); ··· 937 1223 scan_pattern () 938 1224 in 939 1225 let p = scan_pattern () in 940 940 - (* Scan flags *) 1226 1226 + (* Scan flags - collect all identifier characters first *) 941 1227 let flags = Buffer.create 8 in 942 1228 let rec scan_flags () = 943 1229 match Source.cursor_peek cursor with 944 1230 | Some c when is_identifier_continue c -> 945 945 - (* Valid flags: d, g, i, m, s, u, v, y *) 946 946 - (match c with 947 947 - | 'd' | 'g' | 'i' | 'm' | 's' | 'u' | 'v' | 'y' -> 948 948 - Buffer.add_char flags c; 949 949 - Source.cursor_advance cursor; 950 950 - scan_flags () 951 951 - | _ when is_identifier_continue c -> 952 952 - error lexer (Invalid_regexp_flag c) 953 953 - | _ -> ()) 1231 1231 + Buffer.add_char flags c; 1232 1232 + Source.cursor_advance cursor; 1233 1233 + scan_flags () 954 1234 | _ -> () 955 1235 in 956 1236 scan_flags (); 957 957 - Token.Regexp (p, Buffer.contents flags) 1237 1237 + let flags_str = Buffer.contents flags in 1238 1238 + (* Validate the regexp pattern and flags *) 1239 1239 + (try 1240 1240 + let _ = Regexp_validator.validate ~pattern:p ~flags:flags_str in 1241 1241 + () 1242 1242 + with Regexp_validator.Regexp_error e -> 1243 1243 + error lexer (Invalid_regexp (Regexp_validator.show_error e))); 1244 1244 + Token.Regexp (p, flags_str) 958 1245 959 1246 (* Scan identifier content - shared by scan_identifier and scan_private_identifier *) 960 1247 let scan_identifier_content lexer = ··· 998 1285 | _ -> error lexer (Invalid_unicode_escape "incomplete") 999 1286 in 1000 1287 scan_hex (); 1288 1288 + (* Validate the escaped character is a valid identifier character *) 1289 1289 + let is_first = Buffer.length buf = 0 in 1290 1290 + if !value <= 0x7F then begin 1291 1291 + (* ASCII range - check against simple identifier rules *) 1292 1292 + let c = Char.chr !value in 1293 1293 + if is_first then begin 1294 1294 + if not (is_identifier_start c) then 1295 1295 + error lexer (Invalid_unicode_escape "not a valid identifier start character") 1296 1296 + end else begin 1297 1297 + if not (is_identifier_continue c) then 1298 1298 + error lexer (Invalid_unicode_escape "not a valid identifier character") 1299 1299 + end 1300 1300 + end else begin 1301 1301 + (* Unicode range - check against Unicode ID_Start/ID_Continue *) 1302 1302 + if is_first then begin 1303 1303 + if not (is_unicode_id_start !value) then 1304 1304 + error lexer (Invalid_unicode_escape "not a valid identifier start character") 1305 1305 + end else begin 1306 1306 + if not (is_unicode_id_continue !value) then 1307 1307 + error lexer (Invalid_unicode_escape "not a valid identifier character") 1308 1308 + end 1309 1309 + end; 1001 1310 (* Convert code point to character(s) *) 1002 1311 if !value <= 0x7F then 1003 1312 Buffer.add_char buf (Char.chr !value) ··· 1034 1343 | _ -> error lexer (Invalid_unicode_escape "expected hex digit") 1035 1344 in 1036 1345 let value = (d1 lsl 12) lor (d2 lsl 8) lor (d3 lsl 4) lor d4 in 1346 1346 + (* Validate the escaped character is a valid identifier character *) 1347 1347 + let is_first = Buffer.length buf = 0 in 1348 1348 + if value <= 0x7F then begin 1349 1349 + let c = Char.chr value in 1350 1350 + if is_first then begin 1351 1351 + if not (is_identifier_start c) then 1352 1352 + error lexer (Invalid_unicode_escape "not a valid identifier start character") 1353 1353 + end else begin 1354 1354 + if not (is_identifier_continue c) then 1355 1355 + error lexer (Invalid_unicode_escape "not a valid identifier character") 1356 1356 + end 1357 1357 + end else begin 1358 1358 + if is_first then begin 1359 1359 + if not (is_unicode_id_start value) then 1360 1360 + error lexer (Invalid_unicode_escape "not a valid identifier start character") 1361 1361 + end else begin 1362 1362 + if not (is_unicode_id_continue value) then 1363 1363 + error lexer (Invalid_unicode_escape "not a valid identifier character") 1364 1364 + end 1365 1365 + end; 1037 1366 if value <= 0x7F then 1038 1367 Buffer.add_char buf (Char.chr value) 1039 1368 else if value <= 0x7FF then begin ··· 1055 1384 let scan_private_identifier lexer = 1056 1385 let cursor = lexer.cursor in 1057 1386 Source.cursor_advance cursor; (* Skip '#' *) 1387 1387 + (* Check that # is immediately followed by identifier start (no space allowed) *) 1388 1388 + (match Source.cursor_peek cursor with 1389 1389 + | Some c when is_identifier_start c -> () 1390 1390 + | Some '\\' -> () (* Unicode escape is allowed *) 1391 1391 + | Some c when Char.code c >= 0x80 -> () (* Unicode char might be ID_Start *) 1392 1392 + | _ -> error lexer Invalid_private_identifier); 1058 1393 let s = scan_identifier_content lexer in 1394 1394 + if String.length s = 0 then error lexer Invalid_private_identifier; 1059 1395 Token.Private_identifier s 1060 1396 1061 1397 (* Skip hashbang comment at the start of source *) ··· 1114 1450 1115 1451 (* Numbers *) 1116 1452 | '0'..'9' -> 1117 1117 - scan_number lexer 1453 1453 + let tok = scan_number lexer in 1454 1454 + check_numeric_followed_by_ident lexer; 1455 1455 + tok 1118 1456 | '.' -> 1119 1457 (match Source.cursor_peek_n cursor 2 with 1120 1458 | Some s when String.length s >= 2 && is_digit s.[1] -> 1121 1121 - scan_number lexer 1459 1459 + let tok = scan_number lexer in 1460 1460 + check_numeric_followed_by_ident lexer; 1461 1461 + tok 1122 1462 | _ -> 1123 1463 Source.cursor_advance cursor; 1124 1464 (match Source.cursor_peek_n cursor 2 with ··· 1315 1655 1316 1656 (* Update allow_regexp based on token *) 1317 1657 lexer.allow_regexp <- (match tok with 1318 1318 - | Token.Identifier _ | Token.Private_identifier _ 1658 1658 + | Token.Identifier _ | Token.Private_identifier _ | Token.Escaped_identifier _ 1319 1659 | Token.Number _ | Token.BigInt _ | Token.String _ 1320 1660 | Token.Regexp _ | Token.Template (Token.Template_no_sub _) 1321 1661 | Token.Template (Token.Template_tail _) ··· 1351 1691 1352 1692 token 1353 1693 1694 1694 + (* Peek two tokens ahead without consuming *) 1695 1695 + let peek2 lexer = 1696 1696 + let saved_cursor = Source.cursor_save lexer.cursor in 1697 1697 + let saved_newline = lexer.newline_before in 1698 1698 + let saved_allow_regexp = lexer.allow_regexp in 1699 1699 + 1700 1700 + let _ = next_token lexer in 1701 1701 + let token2 = next_token lexer in 1702 1702 + 1703 1703 + Source.cursor_restore lexer.cursor saved_cursor; 1704 1704 + lexer.newline_before <- saved_newline; 1705 1705 + lexer.allow_regexp <- saved_allow_regexp; 1706 1706 + 1707 1707 + token2 1708 1708 + 1709 1709 + (* Peek three tokens ahead without consuming *) 1710 1710 + let peek3 lexer = 1711 1711 + let saved_cursor = Source.cursor_save lexer.cursor in 1712 1712 + let saved_newline = lexer.newline_before in 1713 1713 + let saved_allow_regexp = lexer.allow_regexp in 1714 1714 + 1715 1715 + let _ = next_token lexer in 1716 1716 + let _ = next_token lexer in 1717 1717 + let token3 = next_token lexer in 1718 1718 + 1719 1719 + Source.cursor_restore lexer.cursor saved_cursor; 1720 1720 + lexer.newline_before <- saved_newline; 1721 1721 + lexer.allow_regexp <- saved_allow_regexp; 1722 1722 + 1723 1723 + token3 1724 1724 + 1354 1725 (* Error formatting *) 1355 1726 let pp_error fmt = function 1356 1727 | Unexpected_char c -> Format.fprintf fmt "Unexpected character: '%c'" c ··· 1363 1734 | Unterminated_regexp -> Format.fprintf fmt "Unterminated regular expression" 1364 1735 | Unterminated_template -> Format.fprintf fmt "Unterminated template literal" 1365 1736 | Invalid_regexp_flag c -> Format.fprintf fmt "Invalid regexp flag: '%c'" c 1737 1737 + | Invalid_regexp s -> Format.fprintf fmt "Invalid regular expression: %s" s 1366 1738 | Legacy_octal_in_strict_mode -> Format.fprintf fmt "Octal literals are not allowed in strict mode" 1739 1739 + | Invalid_private_identifier -> Format.fprintf fmt "Private identifier must be followed immediately by an identifier" 1740 1740 + | Numeric_followed_by_ident -> Format.fprintf fmt "Identifier starts immediately after numeric literal" 1367 1741 1368 1742 let show_error err = Format.asprintf "%a" pp_error err

+62 -23

lib/quickjs/parser/lexer.mli

reviewed

··· 1 1 - (** Handwritten JavaScript lexer. *) 1 1 + (** Handwritten JavaScript lexer. 2 2 + 3 3 + A recursive-descent lexer for ECMAScript 2024 that handles all modern 4 4 + JavaScript syntax including template literals, Unicode identifiers, 5 5 + BigInt, and private class fields. *) 6 6 + 7 7 + (** {1 Error Types} *) 2 8 9 9 + (** Lexer errors that can occur during tokenization. *) 3 10 type error = 4 4 - | Unexpected_char of char 5 5 - | Unexpected_eof 6 6 - | Invalid_number of string 7 7 - | Invalid_escape_sequence of string 8 8 - | Invalid_unicode_escape of string 9 9 - | Unterminated_string 10 10 - | Unterminated_comment 11 11 - | Unterminated_regexp 12 12 - | Unterminated_template 13 13 - | Invalid_regexp_flag of char 14 14 - | Legacy_octal_in_strict_mode 11 11 + | Unexpected_char of char (** Encountered an unexpected character *) 12 12 + | Unexpected_eof (** Unexpected end of file *) 13 13 + | Invalid_number of string (** Malformed numeric literal *) 14 14 + | Invalid_escape_sequence of string (** Invalid escape in string/template *) 15 15 + | Invalid_unicode_escape of string (** Invalid \uXXXX or \u{...} escape *) 16 16 + | Unterminated_string (** String literal not closed *) 17 17 + | Unterminated_comment (** Block comment not closed *) 18 18 + | Unterminated_regexp (** Regular expression not closed *) 19 19 + | Unterminated_template (** Template literal not closed *) 20 20 + | Invalid_regexp_flag of char (** Unknown regular expression flag *) 21 21 + | Invalid_regexp of string (** Malformed regular expression *) 22 22 + | Legacy_octal_in_strict_mode (** Octal escape in strict mode *) 23 23 + | Invalid_private_identifier (** Invalid private field name *) 24 24 + | Numeric_followed_by_ident (** Number immediately followed by identifier *) 15 25 26 26 + (** Exception raised when a lexer error occurs. *) 16 27 exception Lexer_error of error * Source.loc 17 28 29 29 + (** {1 Lexer Type} *) 30 30 + 31 31 + (** The lexer state. Opaque type that tracks position, context, and mode. *) 18 32 type t 19 33 20 20 - (** Create a new lexer *) 34 34 + (** {1 Construction} *) 35 35 + 36 36 + (** [create ~filename ~content] creates a new lexer for the given source. 37 37 + @param filename The filename for error reporting 38 38 + @param content The JavaScript source code to tokenize *) 21 39 val create : filename:string -> content:string -> t 22 40 23 23 - (** Set strict mode (affects handling of certain constructs) *) 41 41 + (** {1 Configuration} *) 42 42 + 43 43 + (** [set_strict_mode lexer strict] enables or disables strict mode. 44 44 + In strict mode, octal escapes and certain reserved words are errors. *) 24 45 val set_strict_mode : t -> bool -> unit 25 46 26 26 - (** Set whether regexp is allowed as next token (vs division) *) 47 47 + (** [set_allow_regexp lexer allow] controls whether the next token can be 48 48 + a regular expression literal. This is context-dependent: after operators 49 49 + regexp is allowed, after identifiers division is expected. *) 27 50 val set_allow_regexp : t -> bool -> unit 28 51 29 29 - (** Reposition the lexer to a specific position (for re-scanning) *) 52 52 + (** [goto_pos lexer pos] repositions the lexer to a specific source position. 53 53 + Used for re-scanning when the parser needs to backtrack. *) 30 54 val goto_pos : t -> Source.pos -> unit 31 55 32 32 - (** Get next token *) 56 56 + (** {1 Tokenization} *) 57 57 + 58 58 + (** [next_token lexer] consumes and returns the next token from the input. *) 33 59 val next_token : t -> Token.token 34 60 35 35 - (** Peek at next token without consuming *) 61 61 + (** [peek lexer] returns the next token without consuming it. *) 36 62 val peek : t -> Token.token 37 63 38 38 - (** Continue scanning template literal after expression *) 64 64 + (** [peek2 lexer] returns the second token ahead without consuming any. *) 65 65 + val peek2 : t -> Token.token 66 66 + 67 67 + (** [peek3 lexer] returns the third token ahead without consuming any. *) 68 68 + val peek3 : t -> Token.token 69 69 + 70 70 + (** [scan_template_tail lexer] continues scanning a template literal after 71 71 + an embedded expression [\}]. Returns either a middle or tail part. *) 39 72 val scan_template_tail : t -> Token.token 40 73 41 41 - (** Lexer state for save/restore (for lookahead parsing) *) 74 74 + (** {1 State Management} *) 75 75 + 76 76 + (** Saved lexer state for lookahead parsing and backtracking. *) 42 77 type state 43 78 44 44 - (** Save current lexer state *) 79 79 + (** [save lexer] captures the current lexer state for later restoration. *) 45 80 val save : t -> state 46 81 47 47 - (** Restore lexer to a previously saved state *) 82 82 + (** [restore lexer state] resets the lexer to a previously saved state. *) 48 83 val restore : t -> state -> unit 49 84 50 50 - (** Error formatting *) 85 85 + (** {1 Error Formatting} *) 86 86 + 87 87 + (** [pp_error fmt err] pretty-prints a lexer error. *) 51 88 val pp_error : Format.formatter -> error -> unit 89 89 + 90 90 + (** [show_error err] returns a string representation of the error. *) 52 91 val show_error : error -> string

+2665 -293

lib/quickjs/parser/parser.ml

reviewed

··· 17 17 | Strict_mode_with 18 18 | Strict_mode_octal 19 19 | Invalid_destructuring 20 20 + | Duplicate_parameter of string 21 21 + | Rest_parameter_last 22 22 + | Strict_reserved_word of string 23 23 + | Strict_eval_arguments of string 24 24 + | Use_strict_non_simple_params 25 25 + | Private_static_getter_setter_mismatch 26 26 + | Invalid_class_name of string 27 27 + | Invalid_binding_identifier of string 28 28 + | Invalid_label_identifier of string 29 29 + | Escaped_keyword of string 30 30 + | Await_in_parameter 31 31 + | Yield_in_parameter 32 32 + | Illegal_newline_after_throw 33 33 + | Let_in_lexical_binding 34 34 + | Duplicate_default 35 35 + | Const_no_initializer 36 36 + | For_in_of_const_no_init 37 37 + | Invalid_lhs_in_for 38 38 + | Invalid_regex_flag of string 39 39 + | Duplicate_regex_flag of char 40 40 + | Invalid_regex_pattern of string 41 41 + | Getter_with_parameters 42 42 + | Setter_wrong_param_count 43 43 + | Super_call_outside_constructor 44 44 + | Escaped_contextual_keyword of string 45 45 + | Static_prototype_method 46 46 + | Private_constructor 47 47 + | Cannot_use_new_with_import 48 48 + | Constructor_field 49 49 + | Arguments_in_class_field 50 50 + | Super_in_class_field 51 51 + | New_target_outside_function 52 52 + | Super_outside_method 53 53 + | Super_private_access 54 54 + | Import_export_in_script 55 55 + | Using_in_for_in 56 56 + | Using_at_script_top_level 57 57 + | Using_destructuring_pattern 58 58 + | Using_not_in_block 59 59 + | Function_in_single_statement 60 60 + | Multiple_bindings_in_for 61 61 + | Duplicate_private_name of string 62 62 + | Undeclared_private_name of string 63 63 + | Duplicate_binding of string 64 64 + | Special_constructor 65 65 + | Duplicate_constructor 66 66 + | Duplicate_export of string 67 67 + | Invalid_shorthand_initializer 68 68 + | Duplicate_proto 69 69 + | Nullish_mixing_logical 70 70 + | Invalid_template_escape 71 71 + | Unpaired_surrogate_in_export_name 72 72 + | String_local_export_binding 73 73 + | Undeclared_export of string 74 74 + | Duplicate_attribute_key of string 75 75 + | Default_export_binding_exists of string 20 76 21 77 exception Parse_error of error * Source.loc 22 78 79 79 + (* Variable binding kinds for scope tracking *) 80 80 + type var_binding_kind = 81 81 + | Bind_var (* var declaration *) 82 82 + | Bind_let (* let declaration *) 83 83 + | Bind_const (* const declaration *) 84 84 + | Bind_function (* function declaration *) 85 85 + | Bind_generator_or_async (* generator or async function declaration - always lexical *) 86 86 + | Bind_class (* class declaration *) 87 87 + | Bind_param (* function parameter *) 88 88 + | Bind_catch (* catch clause parameter *) 89 89 + 90 90 + type var_binding = { 91 91 + bind_name : string; 92 92 + bind_kind : var_binding_kind; 93 93 + bind_loc : Source.loc; 94 94 + } 95 95 + 96 96 + (* Scope for tracking variable bindings *) 97 97 + type scope = { 98 98 + scope_bindings : (string, var_binding) Hashtbl.t; 99 99 + scope_is_function : bool; (* var declarations hoist to function scope *) 100 100 + } 101 101 + 23 102 type t = { 24 103 lexer : Lexer.t; 25 104 mutable current : Token.token; 26 105 mutable strict_mode : bool; 27 106 mutable in_module : bool; (* Parsing as module (await is reserved) *) 28 28 - mutable in_function : bool; 107 107 + mutable in_function : bool; (* In any function (for return statement) *) 108 108 + mutable in_non_arrow_function : bool; (* In non-arrow function (for new.target) *) 29 109 mutable in_generator : bool; 30 110 mutable in_async : bool; 31 111 mutable in_iteration : bool; 32 112 mutable in_switch : bool; 113 113 + mutable in_static_block : bool; (* In class static initialization block (await reserved) *) 114 114 + mutable in_class_field_init : bool; (* In class field initializer (arguments forbidden) *) 115 115 + mutable in_formal_parameters : bool; (* In function formal parameters (yield/await expressions forbidden) *) 116 116 + mutable super_call_forbidden : bool; (* Super() call is forbidden (set in class field init, even in arrow functions) *) 117 117 + mutable in_derived_class : bool; (* True when in a class that extends another - super() only allowed here *) 118 118 + mutable allow_super_property : bool; (* super.x is allowed (in methods, static blocks) *) 33 119 mutable allow_in : bool; (* Allow 'in' as binary operator *) 34 34 - mutable labels : string list; 120 120 + mutable in_block : bool; (* In block statement or function body - using/await-using allowed *) 121 121 + mutable labels : string list; (* All labels (for break) *) 122 122 + mutable iteration_labels : string list; (* Labels on iteration statements only (for continue) *) 123 123 + exported_names : (string, Source.loc) Hashtbl.t; (* Track exported names for duplicate detection *) 124 124 + mutable pending_export_bindings : (string * Source.loc) list; (* Local bindings to validate at end of module *) 125 125 + mutable scopes : scope list; (* Stack of scopes for redeclaration detection *) 126 126 + mutable private_name_scopes : private_name_scope list; (* Stack of private name scopes for AllPrivateNamesValid *) 127 127 + } 128 128 + 129 129 + (* Each class has its own private name scope with declared names and pending references *) 130 130 + and private_name_scope = { 131 131 + mutable declared : string list; (* Private names declared in this class *) 132 132 + mutable pending : (string * Source.loc) list; (* References to check at end of class *) 35 133 } 36 134 37 135 let create lexer = 38 136 let current = Lexer.next_token lexer in 137 137 + let global_scope = { scope_bindings = Hashtbl.create 16; scope_is_function = true } in 39 138 { 40 139 lexer; 41 140 current; 42 141 strict_mode = false; 43 142 in_module = false; 44 143 in_function = false; 144 144 + in_non_arrow_function = false; 45 145 in_generator = false; 46 146 in_async = false; 47 147 in_iteration = false; 48 148 in_switch = false; 149 149 + in_static_block = false; 150 150 + in_class_field_init = false; 151 151 + in_formal_parameters = false; 152 152 + super_call_forbidden = false; 153 153 + in_derived_class = false; 154 154 + allow_super_property = false; 49 155 allow_in = true; (* Default: allow 'in' as binary operator *) 156 156 + in_block = true; (* Start true for top-level; switch cases set to false *) 50 157 labels = []; 158 158 + iteration_labels = []; 159 159 + exported_names = Hashtbl.create 16; 160 160 + pending_export_bindings = []; 161 161 + scopes = [global_scope]; 162 162 + private_name_scopes = []; (* No private names valid at top level *) 51 163 } 52 164 53 165 let error parser err = 54 166 raise (Parse_error (err, parser.current.loc)) 55 167 168 168 + (* Decode next UTF-8 code point from string starting at position i. 169 169 + Returns (code_point, bytes_consumed). *) 170 170 + let decode_utf8 s i = 171 171 + let len = String.length s in 172 172 + if i >= len then (0, 0) 173 173 + else 174 174 + let byte = Char.code s.[i] in 175 175 + if byte < 0x80 then 176 176 + (byte, 1) 177 177 + else if byte < 0xC0 then 178 178 + (* Invalid - continuation byte at start *) 179 179 + (byte, 1) 180 180 + else if byte < 0xE0 then begin 181 181 + if i + 1 < len then 182 182 + let b2 = Char.code s.[i + 1] in 183 183 + let cp = ((byte land 0x1F) lsl 6) lor (b2 land 0x3F) in 184 184 + (cp, 2) 185 185 + else (byte, 1) 186 186 + end else if byte < 0xF0 then begin 187 187 + if i + 2 < len then 188 188 + let b2 = Char.code s.[i + 1] in 189 189 + let b3 = Char.code s.[i + 2] in 190 190 + let cp = ((byte land 0x0F) lsl 12) lor ((b2 land 0x3F) lsl 6) lor (b3 land 0x3F) in 191 191 + (cp, 3) 192 192 + else (byte, 1) 193 193 + end else begin 194 194 + if i + 3 < len then 195 195 + let b2 = Char.code s.[i + 1] in 196 196 + let b3 = Char.code s.[i + 2] in 197 197 + let b4 = Char.code s.[i + 3] in 198 198 + let cp = ((byte land 0x07) lsl 18) lor ((b2 land 0x3F) lsl 12) lor 199 199 + ((b3 land 0x3F) lsl 6) lor (b4 land 0x3F) in 200 200 + (cp, 4) 201 201 + else (byte, 1) 202 202 + end 203 203 + 204 204 + (* Check if a string contains unpaired surrogates. 205 205 + Per spec: IsStringWellFormedUnicode returns false if the string contains 206 206 + a high surrogate (D800-DBFF) not followed by a low surrogate (DC00-DFFF), 207 207 + or a low surrogate not preceded by a high surrogate. *) 208 208 + let has_unpaired_surrogate s = 209 209 + let len = String.length s in 210 210 + let i = ref 0 in 211 211 + let prev_was_high = ref false in 212 212 + let result = ref false in 213 213 + while !i < len && not !result do 214 214 + let (cp, consumed) = decode_utf8 s !i in 215 215 + let is_high = cp >= 0xD800 && cp <= 0xDBFF in 216 216 + let is_low = cp >= 0xDC00 && cp <= 0xDFFF in 217 217 + if is_low then begin 218 218 + (* Low surrogate - must be preceded by high surrogate *) 219 219 + if not !prev_was_high then result := true 220 220 + end else if !prev_was_high then begin 221 221 + (* Previous was high but current is not low - unpaired high *) 222 222 + result := true 223 223 + end; 224 224 + prev_was_high := is_high; 225 225 + i := !i + consumed 226 226 + done; 227 227 + (* Check if string ends with unpaired high surrogate *) 228 228 + if !prev_was_high && not !result then result := true; 229 229 + !result 230 230 + 231 231 + (* Scope management functions for redeclaration detection *) 232 232 + 233 233 + let push_scope parser ~is_function = 234 234 + let new_scope = { scope_bindings = Hashtbl.create 16; scope_is_function = is_function } in 235 235 + parser.scopes <- new_scope :: parser.scopes 236 236 + 237 237 + let pop_scope parser = 238 238 + match parser.scopes with 239 239 + | [] -> failwith "pop_scope: empty scope stack" 240 240 + | _ :: rest -> parser.scopes <- rest 241 241 + 242 242 + let current_scope parser = 243 243 + match parser.scopes with 244 244 + | [] -> failwith "current_scope: empty scope stack" 245 245 + | s :: _ -> s 246 246 + 247 247 + (* Record a private name reference for later validation. 248 248 + This is called when we encounter a private name in an expression context. 249 249 + Validation is deferred to the end of the class body to handle forward references. *) 250 250 + let record_private_name_ref parser name loc = 251 251 + match parser.private_name_scopes with 252 252 + | [] -> raise (Parse_error (Undeclared_private_name name, loc)) (* Not in any class *) 253 253 + | scope :: _ -> 254 254 + (* Add to pending references for this scope *) 255 255 + scope.pending <- (name, loc) :: scope.pending 256 256 + 257 257 + (* Check if a private name is declared in any enclosing class scope *) 258 258 + let is_private_name_declared parser name = 259 259 + let rec check_scopes = function 260 260 + | [] -> false 261 261 + | scope :: rest -> 262 262 + if List.mem name scope.declared then true 263 263 + else check_scopes rest 264 264 + in 265 265 + check_scopes parser.private_name_scopes 266 266 + 267 267 + (* Validate all pending private name references in the current scope. 268 268 + Called at the end of a class body. *) 269 269 + let validate_pending_private_names parser = 270 270 + match parser.private_name_scopes with 271 271 + | [] -> () 272 272 + | scope :: _ -> 273 273 + List.iter (fun (name, loc) -> 274 274 + if not (is_private_name_declared parser name) then 275 275 + raise (Parse_error (Undeclared_private_name name, loc)) 276 276 + ) scope.pending 277 277 + 278 278 + (* Check if a binding would conflict with an existing lexical declaration. 279 279 + For let/const/class: error if already declared in same scope. 280 280 + For var: error if any enclosing lexical scope has the same name. *) 281 281 + let check_redeclaration parser name kind loc = 282 282 + (* Check if a binding is lexical (can't be redeclared with var). 283 283 + Function declarations (including generators and async) in block scopes are lexical, 284 284 + but in function scope they're not. 285 285 + Annex B exception: in non-strict mode, var can redeclare catch parameters. *) 286 286 + let is_lexical_in_scope scope = function 287 287 + | Bind_let | Bind_const | Bind_class -> true 288 288 + | Bind_catch -> parser.strict_mode (* Annex B: var can redeclare catch in non-strict mode *) 289 289 + | Bind_function | Bind_generator_or_async -> not scope.scope_is_function (* Functions are lexical only in block scopes *) 290 290 + | Bind_var | Bind_param -> false 291 291 + in 292 292 + match kind with 293 293 + | Bind_let | Bind_const | Bind_class -> 294 294 + (* Lexical declarations can't redeclare anything in the same scope. *) 295 295 + let scope = current_scope parser in 296 296 + (match Hashtbl.find_opt scope.scope_bindings name with 297 297 + | Some _existing -> 298 298 + (* Redeclaration of any binding (lexical or var) in same scope is an error *) 299 299 + raise (Parse_error (Duplicate_binding name, loc)) 300 300 + | None -> ()) 301 301 + | Bind_generator_or_async -> 302 302 + (* Generator/async functions: stricter than regular functions *) 303 303 + let scope = current_scope parser in 304 304 + (match Hashtbl.find_opt scope.scope_bindings name with 305 305 + | Some existing -> 306 306 + (* In strict mode, can't redeclare anything *) 307 307 + if parser.strict_mode then 308 308 + raise (Parse_error (Duplicate_binding name, loc)) 309 309 + else begin 310 310 + if scope.scope_is_function then begin 311 311 + (* At function scope, can't redeclare let/const/class *) 312 312 + match existing.bind_kind with 313 313 + | Bind_let | Bind_const | Bind_class -> 314 314 + raise (Parse_error (Duplicate_binding name, loc)) 315 315 + | _ -> () (* Can redeclare var, functions, generators in sloppy mode at function scope *) 316 316 + end else begin 317 317 + (* In block scope, generator/async is lexical - can't redeclare anything *) 318 318 + raise (Parse_error (Duplicate_binding name, loc)) 319 319 + end 320 320 + end 321 321 + | None -> ()) 322 322 + | Bind_function -> 323 323 + (* Regular functions: check for conflicts in current scope *) 324 324 + let scope = current_scope parser in 325 325 + (match Hashtbl.find_opt scope.scope_bindings name with 326 326 + | Some existing -> 327 327 + (* In strict mode, functions behave like let - can't redeclare anything *) 328 328 + if parser.strict_mode then 329 329 + raise (Parse_error (Duplicate_binding name, loc)) 330 330 + else begin 331 331 + (* In sloppy mode: 332 332 + - At function scope: can redeclare var and other functions (including generators) 333 333 + - In block scope: functions are lexical, can only redeclare other regular functions *) 334 334 + if scope.scope_is_function then begin 335 335 + (* At function scope, can't redeclare let/const/class *) 336 336 + match existing.bind_kind with 337 337 + | Bind_let | Bind_const | Bind_class -> 338 338 + raise (Parse_error (Duplicate_binding name, loc)) 339 339 + | _ -> () 340 340 + end else begin 341 341 + (* In block scope, function is lexical - can only redeclare other regular functions *) 342 342 + match existing.bind_kind with 343 343 + | Bind_function -> () (* Regular functions can redeclare other regular functions in sloppy mode *) 344 344 + | _ -> 345 345 + raise (Parse_error (Duplicate_binding name, loc)) 346 346 + end 347 347 + end 348 348 + | None -> ()) 349 349 + | Bind_var -> 350 350 + (* Check all enclosing scopes up to function boundary for lexical declarations *) 351 351 + let rec check_scopes = function 352 352 + | [] -> () 353 353 + | scope :: rest -> 354 354 + (match Hashtbl.find_opt scope.scope_bindings name with 355 355 + | Some existing when is_lexical_in_scope scope existing.bind_kind -> 356 356 + raise (Parse_error (Duplicate_binding name, loc)) 357 357 + | _ -> ()); 358 358 + if not scope.scope_is_function then 359 359 + check_scopes rest 360 360 + in 361 361 + check_scopes parser.scopes 362 362 + | Bind_param | Bind_catch -> 363 363 + (* Parameters and catch bindings just need to check current scope *) 364 364 + let scope = current_scope parser in 365 365 + (match Hashtbl.find_opt scope.scope_bindings name with 366 366 + | Some _ -> raise (Parse_error (Duplicate_binding name, loc)) 367 367 + | None -> ()) 368 368 + 369 369 + (* Add a binding to the current scope. 370 370 + For var bindings, we also propagate to all enclosing block scopes up to the 371 371 + function boundary so that lexical declarations can detect the conflict. *) 372 372 + let add_binding parser name kind loc = 373 373 + check_redeclaration parser name kind loc; 374 374 + let binding = { bind_name = name; bind_kind = kind; bind_loc = loc } in 375 375 + match kind with 376 376 + | Bind_var -> 377 377 + (* Propagate var binding to all enclosing scopes up to function scope *) 378 378 + let rec add_to_scopes = function 379 379 + | [] -> () 380 380 + | scope :: rest -> 381 381 + Hashtbl.replace scope.scope_bindings name binding; 382 382 + if not scope.scope_is_function then 383 383 + add_to_scopes rest 384 384 + in 385 385 + add_to_scopes parser.scopes 386 386 + | _ -> 387 387 + (* Other bindings only go to current scope *) 388 388 + let scope = current_scope parser in 389 389 + Hashtbl.replace scope.scope_bindings name binding 390 390 + 391 391 + (** Register an exported name and check for duplicates *) 392 392 + let register_export_name parser name loc = 393 393 + if Hashtbl.mem parser.exported_names name then 394 394 + raise (Parse_error (Duplicate_export name, loc)) 395 395 + else 396 396 + Hashtbl.add parser.exported_names name loc 397 397 + 398 398 + (** Extract all bound names from a pattern (for duplicate parameter checking) *) 399 399 + let rec collect_bound_names_from_pattern (pat : Ast.pattern) : (string * Source.loc) list = 400 400 + match pat.pat with 401 401 + | Ast.Pat_identifier id -> [(id.name, id.loc)] 402 402 + | Ast.Pat_array elements -> 403 403 + List.concat_map (function 404 404 + | None -> [] 405 405 + | Some (Ast.Array_pat_element p) -> collect_bound_names_from_pattern p 406 406 + | Some (Ast.Array_pat_rest p) -> collect_bound_names_from_pattern p 407 407 + ) elements 408 408 + | Ast.Pat_object props -> 409 409 + List.concat_map (function 410 410 + | Ast.Object_pat_property { value; _ } -> collect_bound_names_from_pattern value 411 411 + | Ast.Object_pat_rest p -> collect_bound_names_from_pattern p 412 412 + ) props 413 413 + | Ast.Pat_assignment { left; _ } -> collect_bound_names_from_pattern left 414 414 + | Ast.Pat_rest inner -> collect_bound_names_from_pattern inner 415 415 + | Ast.Pat_expression _ -> [] 416 416 + 417 417 + (* Add bindings from a pattern to the current scope *) 418 418 + let add_pattern_bindings parser kind (pat : Ast.pattern) = 419 419 + List.iter (fun (name, loc) -> 420 420 + add_binding parser name kind loc 421 421 + ) (collect_bound_names_from_pattern pat) 422 422 + 423 423 + (** Check if parameter list is simple (no destructuring, defaults, or rest) *) 424 424 + let is_simple_parameter_list (params : Ast.pattern list) : bool = 425 425 + List.for_all (fun pat -> 426 426 + match pat.Ast.pat with 427 427 + | Ast.Pat_identifier _ -> true 428 428 + | _ -> false 429 429 + ) params 430 430 + 431 431 + (** Check if rest parameter is followed by any other parameters or trailing comma *) 432 432 + let has_rest_before_end (params : Ast.pattern list) : bool = 433 433 + let rec check = function 434 434 + | [] -> false 435 435 + | [_] -> false 436 436 + | { Ast.pat = Ast.Pat_rest _; _ } :: _ :: _ -> true 437 437 + | _ :: rest -> check rest 438 438 + in 439 439 + check params 440 440 + 441 441 + (** Check for duplicate parameter names *) 442 442 + let check_duplicate_params _parser (params : Ast.pattern list) : unit = 443 443 + let names = List.concat_map collect_bound_names_from_pattern params in 444 444 + let seen = Hashtbl.create 16 in 445 445 + List.iter (fun (name, loc) -> 446 446 + if Hashtbl.mem seen name then begin 447 447 + (* Report at the location of the duplicate *) 448 448 + raise (Parse_error (Duplicate_parameter name, loc)) 449 449 + end; 450 450 + Hashtbl.add seen name () 451 451 + ) names 452 452 + 453 453 + (** Get identifier name from token, returns (name, is_escaped) *) 454 454 + let identifier_of_token = function 455 455 + | Token.Identifier name -> Some (name, false) 456 456 + | Token.Escaped_identifier name -> Some (name, true) 457 457 + | _ -> None 458 458 + 459 459 + (** Check that a using/await-using declaration only has simple identifier bindings. 460 460 + Destructuring patterns are not allowed. *) 461 461 + let check_using_bindings_are_identifiers (decl : Ast.var_declaration) = 462 462 + List.iter (fun (declarator : Ast.var_declarator) -> 463 463 + match declarator.var_id.pat with 464 464 + | Ast.Pat_identifier _ -> () (* OK - simple identifier *) 465 465 + | _ -> raise (Parse_error (Using_destructuring_pattern, declarator.var_id.loc)) 466 466 + ) decl.var_declarations 467 467 + 468 468 + (** Pre-scan for "use strict" directive in function/script body. 469 469 + This must be done BEFORE parsing to ensure strict mode is set before 470 470 + lexing strings that contain octal escapes. 471 471 + 472 472 + The saved_lexer_state must be captured BEFORE lexing the first body token. 473 473 + Call this function after lexing the first body token (parser.current is set). 474 474 + 475 475 + If "use strict" is found: 476 476 + - Restores lexer to saved_lexer_state 477 477 + - Sets strict mode on both parser and lexer 478 478 + - Re-lexes the first token with strict mode (to catch octal escapes) 479 479 + Returns true if "use strict" was found. *) 480 480 + let prescan_for_use_strict parser saved_lexer_state = 481 481 + let result = ref false in 482 482 + (* Scan tokens looking for directive prologue. 483 483 + parser.current already has the first body token. *) 484 484 + (try 485 485 + while not !result && parser.current.tok <> Token.RBrace && parser.current.tok <> Token.Eof do 486 486 + match parser.current.tok with 487 487 + | Token.String (s, _) -> 488 488 + (* Check if this is "use strict" *) 489 489 + if s = "use strict" then result := true; 490 490 + parser.current <- Lexer.next_token parser.lexer; 491 491 + (* Check for semicolon or ASI *) 492 492 + (match parser.current.tok with 493 493 + | Token.Semicolon -> parser.current <- Lexer.next_token parser.lexer 494 494 + | Token.RBrace | Token.Eof -> () (* ASI *) 495 495 + | _ when parser.current.preceded_by_newline -> () (* ASI via newline *) 496 496 + | _ -> raise Exit) (* Not a directive, stop *) 497 497 + | _ -> raise Exit (* Not a string literal, stop *) 498 498 + done 499 499 + with Exit -> ()); 500 500 + (* Restore lexer to position before first body token was lexed *) 501 501 + Lexer.restore parser.lexer saved_lexer_state; 502 502 + if !result then begin 503 503 + (* Set strict mode and re-lex the first token to catch octal escapes *) 504 504 + parser.strict_mode <- true; 505 505 + Lexer.set_strict_mode parser.lexer true 506 506 + end; 507 507 + (* Re-lex the first token (either with strict mode or not) *) 508 508 + parser.current <- Lexer.next_token parser.lexer; 509 509 + !result 510 510 + 511 511 + (** Check if token is a contextual keyword (escaped or not) *) 512 512 + let is_contextual_token tok name = 513 513 + match tok with 514 514 + | Token.Identifier n when n = name -> Some false 515 515 + | Token.Escaped_identifier n when n = name -> Some true 516 516 + | _ -> None 517 517 + 56 518 let current_token parser = parser.current.tok 57 519 58 520 let current_loc parser = parser.current.loc ··· 97 559 (** Check if current token can start an expression *) 98 560 let can_start_expression parser = 99 561 match current_token parser with 100 100 - | Token.Identifier _ | Token.Private_identifier _ | Token.Number _ | Token.BigInt _ 562 562 + | Token.Identifier _ | Token.Escaped_identifier _ | Token.Private_identifier _ | Token.Number _ | Token.BigInt _ 101 563 | Token.String _ | Token.Regexp _ 102 564 | Token.Template _ | Token.LParen | Token.LBracket | Token.LBrace 103 565 | Token.Keyword Token.Kw_function | Token.Keyword Token.Kw_class ··· 111 573 | Token.Plus_plus | Token.Minus_minus 112 574 | Token.At (* Decorator start *) 113 575 -> true 576 576 + (* Strict reserved words (let, static, etc) can start expressions in non-strict mode *) 577 577 + | Token.Keyword Token.Kw_let | Token.Keyword Token.Kw_static 578 578 + | Token.Keyword Token.Kw_implements | Token.Keyword Token.Kw_interface 579 579 + | Token.Keyword Token.Kw_package | Token.Keyword Token.Kw_private 580 580 + | Token.Keyword Token.Kw_protected | Token.Keyword Token.Kw_public 581 581 + when not parser.strict_mode -> true 114 582 | _ -> false 115 583 116 584 (** Check if a keyword can be used as identifier in current context *) ··· 129 597 | Token.Kw_accessor -> true 130 598 | _ -> false 131 599 600 600 + (** Check if identifier name is valid in strict mode binding context *) 601 601 + let check_strict_binding_identifier parser name = 602 602 + if parser.strict_mode then begin 603 603 + if name = "eval" || name = "arguments" then 604 604 + error parser (Strict_eval_arguments name) 605 605 + end 606 606 + 607 607 + (** Error found during expression validation *) 608 608 + type expr_validation_error = 609 609 + | Invalid_cover_init of Source.loc 610 610 + | Duplicate_proto_found of Source.loc 611 611 + 612 612 + (** Check for duplicate __proto__ in object literal (non-shorthand, non-method, non-computed) *) 613 613 + let check_duplicate_proto (props : Ast.property list) : Source.loc option = 614 614 + let has_proto = ref false in 615 615 + let result = ref None in 616 616 + List.iter (fun prop -> 617 617 + if Option.is_none !result then 618 618 + match prop with 619 619 + | Ast.Property { key; kind = Ast.Init; computed = false; method_ = false; shorthand = false; _ } -> 620 620 + (match key.Ast.expr with 621 621 + | Ast.Literal (Ast.Lit_string "__proto__") -> 622 622 + if !has_proto then result := Some key.Ast.loc 623 623 + else has_proto := true 624 624 + | _ -> ()) 625 625 + | _ -> () 626 626 + ) props; 627 627 + !result 628 628 + 629 629 + (** Check if an expression contains invalid patterns only allowed in destructuring. 630 630 + Returns the first error found (CoverInitializedName or duplicate __proto__). *) 631 631 + let rec find_object_literal_error (expr : Ast.expression) : expr_validation_error option = 632 632 + match expr.Ast.expr with 633 633 + | Ast.Object props -> 634 634 + (* First check for duplicate __proto__ *) 635 635 + (match check_duplicate_proto props with 636 636 + | Some loc -> Some (Duplicate_proto_found loc) 637 637 + | None -> 638 638 + (* Then check for CoverInitializedName in properties *) 639 639 + List.fold_left (fun found prop -> 640 640 + match found with 641 641 + | Some _ -> found 642 642 + | None -> 643 643 + match prop with 644 644 + | Ast.Property { shorthand = true; value; _ } -> 645 645 + (* Shorthand property with Assignment value is CoverInitializedName *) 646 646 + (match value.Ast.expr with 647 647 + | Ast.Assignment _ -> Some (Invalid_cover_init value.Ast.loc) 648 648 + | _ -> find_object_literal_error value) 649 649 + | Ast.Property { value; _ } -> 650 650 + find_object_literal_error value 651 651 + | Ast.Spread_element e -> 652 652 + find_object_literal_error e 653 653 + ) None props) 654 654 + | Ast.Array elements -> 655 655 + List.fold_left (fun found elem -> 656 656 + match found, elem with 657 657 + | Some _, _ -> found 658 658 + | None, Some e -> find_object_literal_error e 659 659 + | None, None -> None 660 660 + ) None elements 661 661 + | Ast.Paren inner -> 662 662 + find_object_literal_error inner 663 663 + | Ast.Sequence exprs -> 664 664 + List.fold_left (fun found e -> 665 665 + match found with 666 666 + | Some _ -> found 667 667 + | None -> find_object_literal_error e 668 668 + ) None exprs 669 669 + | Ast.Conditional { test; consequent; alternate } -> 670 670 + (match find_object_literal_error test with 671 671 + | Some _ as found -> found 672 672 + | None -> 673 673 + match find_object_literal_error consequent with 674 674 + | Some _ as found -> found 675 675 + | None -> find_object_literal_error alternate) 676 676 + | Ast.Binary { left; right; _ } -> 677 677 + (match find_object_literal_error left with 678 678 + | Some _ as found -> found 679 679 + | None -> find_object_literal_error right) 680 680 + | Ast.Unary { argument; _ } -> 681 681 + find_object_literal_error argument 682 682 + | Ast.Call { callee; arguments; _ } -> 683 683 + (match find_object_literal_error callee with 684 684 + | Some _ as found -> found 685 685 + | None -> 686 686 + List.fold_left (fun found arg -> 687 687 + match found with 688 688 + | Some _ -> found 689 689 + | None -> find_object_literal_error arg 690 690 + ) None arguments) 691 691 + | Ast.Member { object_; property; _ } -> 692 692 + (match find_object_literal_error object_ with 693 693 + | Some _ as found -> found 694 694 + | None -> find_object_literal_error property) 695 695 + | Ast.Spread e -> 696 696 + find_object_literal_error e 697 697 + | Ast.TaggedTemplate { tag; _ } -> 698 698 + find_object_literal_error tag 699 699 + | Ast.New { callee; arguments } -> 700 700 + (match find_object_literal_error callee with 701 701 + | Some _ as found -> found 702 702 + | None -> 703 703 + List.fold_left (fun found arg -> 704 704 + match found with 705 705 + | Some _ -> found 706 706 + | None -> find_object_literal_error arg 707 707 + ) None arguments) 708 708 + | Ast.Await e | Ast.Yield { argument = Some e; _ } -> 709 709 + find_object_literal_error e 710 710 + (* Assignment expressions: only check right side since left becomes a pattern *) 711 711 + | Ast.Assignment { right; _ } -> 712 712 + find_object_literal_error right 713 713 + | _ -> None 714 714 + 715 715 + (** Validate expression doesn't contain invalid patterns *) 716 716 + let validate_expression (expr : Ast.expression) : unit = 717 717 + match find_object_literal_error expr with 718 718 + | Some (Invalid_cover_init loc) -> raise (Parse_error (Invalid_shorthand_initializer, loc)) 719 719 + | Some (Duplicate_proto_found loc) -> raise (Parse_error (Duplicate_proto, loc)) 720 720 + | None -> () 721 721 + 132 722 (** Parse an identifier *) 133 723 let parse_identifier parser = 134 724 match current_token parser with 135 135 - | Token.Identifier name -> 725 725 + | Token.Identifier name | Token.Escaped_identifier name -> 726 726 + (* Escaped reserved keywords (e.g., im\u0070ort) are an error, but 727 727 + strict-only reserved words (like private, public) are OK in non-strict mode *) 728 728 + (match current_token parser with 729 729 + | Token.Escaped_identifier n -> 730 730 + (match Token.keyword_of_string n with 731 731 + | Some kw -> 732 732 + (* Only error if it's a real keyword, or if we're in strict mode 733 733 + and it's a strict reserved word *) 734 734 + if not (is_strict_reserved kw) then 735 735 + error parser (Escaped_keyword n) 736 736 + else if parser.strict_mode then 737 737 + error parser (Escaped_keyword n) 738 738 + | None -> ()) 739 739 + | _ -> ()); 136 740 let loc = current_loc parser in 137 741 advance parser; 138 742 { Ast.name; loc } 139 139 - (* 'await' can be identifier when not in async function and not in module *) 140 140 - | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module -> 743 743 + (* 'await' can be identifier when not in async function, not in module, and not in static block *) 744 744 + | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module && not parser.in_static_block -> 141 745 let loc = current_loc parser in 142 746 advance parser; 143 747 { Ast.name = "await"; loc } ··· 160 764 { Ast.name; loc } 161 765 | _ -> error parser Expected_identifier 162 766 767 767 + (** Check if an identifier name is a strict mode reserved word *) 768 768 + let is_strict_reserved_name name = 769 769 + match name with 770 770 + | "implements" | "interface" | "package" 771 771 + | "private" | "protected" | "public" 772 772 + | "static" | "let" | "yield" -> true 773 773 + | _ -> false 774 774 + 775 775 + (** Parse a class name - class names are always in strict mode context. 776 776 + Class code is always strict mode, so strict reserved words and yield are always invalid. *) 777 777 + let parse_class_name parser = 778 778 + match current_token parser with 779 779 + | Token.Identifier name | Token.Escaped_identifier name -> 780 780 + (* Strict reserved words are not allowed as class names (even when escaped) *) 781 781 + if is_strict_reserved_name name then 782 782 + error parser (Invalid_class_name name); 783 783 + (* yield is always not allowed as class name (class code is strict mode) *) 784 784 + if name = "yield" then 785 785 + error parser (Invalid_class_name name); 786 786 + (* eval and arguments are not allowed as class names *) 787 787 + if name = "eval" || name = "arguments" then 788 788 + error parser (Invalid_class_name name); 789 789 + (* await is not allowed as class name in module, async context, or static block *) 790 790 + if name = "await" && (parser.in_module || parser.in_async || parser.in_static_block) then 791 791 + error parser (Invalid_class_name name); 792 792 + let loc = current_loc parser in 793 793 + advance parser; 794 794 + { Ast.name; loc } 795 795 + (* Contextual keywords can be class names *) 796 796 + | Token.Keyword kw when is_contextual_keyword kw -> 797 797 + let name = Token.keyword_to_string kw in 798 798 + let loc = current_loc parser in 799 799 + advance parser; 800 800 + { Ast.name; loc } 801 801 + (* yield is never allowed as class name (class code is always strict mode) *) 802 802 + | Token.Keyword Token.Kw_yield -> 803 803 + error parser (Invalid_class_name "yield") 804 804 + (* await is not allowed as class name in module, async context, or static block *) 805 805 + | Token.Keyword Token.Kw_await when not parser.in_module && not parser.in_async && not parser.in_static_block -> 806 806 + let loc = current_loc parser in 807 807 + advance parser; 808 808 + { Ast.name = "await"; loc } 809 809 + (* Strict reserved words are NOT allowed as class names *) 810 810 + | Token.Keyword kw when is_strict_reserved kw -> 811 811 + error parser (Invalid_class_name (Token.keyword_to_string kw)) 812 812 + | _ -> error parser Expected_identifier 813 813 + 163 814 (** Parse a literal *) 164 815 let parse_literal parser = 165 816 let loc = current_loc parser in ··· 184 835 | Token.LBracket -> 185 836 advance parser; 186 837 let elements = ref [] in 838 838 + let saw_rest = ref false in 187 839 while current_token parser <> Token.RBracket && not (is_at_end parser) do 188 840 if current_token parser = Token.Comma then begin 189 841 elements := None :: !elements; 190 842 advance parser 191 843 end else if current_token parser = Token.Ellipsis then begin 844 844 + let rest_loc = current_loc parser in 192 845 advance parser; 193 846 let pat = parse_binding_pattern parser in 194 194 - elements := Some (Ast.Array_pat_rest pat) :: !elements 847 847 + elements := Some (Ast.Array_pat_rest pat) :: !elements; 848 848 + saw_rest := true; 849 849 + (* Rest element must be last - error if followed by comma and more elements *) 850 850 + if current_token parser = Token.Comma then begin 851 851 + let next = (Lexer.peek parser.lexer).tok in 852 852 + if next <> Token.RBracket then 853 853 + raise (Parse_error (Rest_parameter_last, rest_loc)) 854 854 + else 855 855 + advance parser (* allow trailing comma after rest *) 856 856 + end 195 857 end else begin 196 858 let pat = parse_binding_pattern parser in 197 859 let pat = ··· 216 878 let props = ref [] in 217 879 while current_token parser <> Token.RBrace && not (is_at_end parser) do 218 880 if current_token parser = Token.Ellipsis then begin 881 881 + let rest_loc = current_loc parser in 219 882 advance parser; 220 883 let id = parse_identifier parser in 221 221 - props := Ast.Object_pat_rest (Ast.mk_pat ~loc:id.loc (Ast.Pat_identifier id)) :: !props 884 884 + props := Ast.Object_pat_rest (Ast.mk_pat ~loc:id.loc (Ast.Pat_identifier id)) :: !props; 885 885 + (* Rest property must be last - error if followed by comma and more properties *) 886 886 + if current_token parser = Token.Comma then begin 887 887 + let next = (Lexer.peek parser.lexer).tok in 888 888 + if next <> Token.RBrace then 889 889 + raise (Parse_error (Rest_parameter_last, rest_loc)) 890 890 + else 891 891 + advance parser (* allow trailing comma after rest *) 892 892 + end 222 893 end else begin 223 894 let computed = current_token parser = Token.LBracket in 224 895 let key = ··· 233 904 k 234 905 end else begin 235 906 match current_token parser with 236 236 - | Token.Identifier name -> 907 907 + | Token.Identifier name | Token.Escaped_identifier name -> 908 908 + (* Check for escaped reserved keyword - but strict-only reserved words 909 909 + are OK in non-strict mode *) 910 910 + let is_escaped = match current_token parser with Token.Escaped_identifier _ -> true | _ -> false in 911 911 + if is_escaped then 912 912 + (match Token.keyword_of_string name with 913 913 + | Some kw when not (is_strict_reserved kw) -> error parser (Escaped_keyword name) 914 914 + | Some _ when parser.strict_mode -> error parser (Escaped_keyword name) 915 915 + | _ -> ()); 237 916 let loc = current_loc parser in 238 917 advance parser; 239 918 Ast.mk_expr ~loc (Ast.Literal (Ast.Lit_string name)) ··· 265 944 end else begin 266 945 match key.expr with 267 946 | Ast.Literal (Ast.Lit_string name) -> 947 947 + (* Shorthand property pattern - name becomes binding identifier 948 948 + Need to validate it as an identifier reference. 949 949 + Reserved keywords like extends, class, etc. are NOT allowed. *) 950 950 + (match Token.keyword_of_string name with 951 951 + | Some Token.Kw_yield -> 952 952 + if parser.in_generator || parser.strict_mode then 953 953 + error parser (Invalid_binding_identifier name) 954 954 + | Some Token.Kw_await -> 955 955 + if parser.in_async || parser.in_module || parser.in_static_block then 956 956 + error parser (Invalid_binding_identifier name) 957 957 + | Some kw when not (is_strict_reserved kw) && not (is_contextual_keyword kw) -> 958 958 + (* True reserved keyword - never allowed as identifier *) 959 959 + error parser (Unexpected_token (Token.Keyword kw)) 960 960 + | _ -> ()); 961 961 + if parser.strict_mode && is_strict_reserved_name name then 962 962 + error parser (Strict_reserved_word name); 268 963 let id = { Ast.name; loc = key.loc } in 269 964 (Ast.mk_pat ~loc:key.loc (Ast.Pat_identifier id), true) 270 965 | _ -> error parser Expected_identifier ··· 287 982 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 288 983 Ast.mk_pat ~loc (Ast.Pat_object (List.rev !props)) 289 984 290 290 - | Token.Identifier name -> 985 985 + | Token.Identifier name | Token.Escaped_identifier name -> 986 986 + (* Check if identifier name is a reserved word (catches escaped keywords) *) 987 987 + let is_escaped = match current_token parser with Token.Escaped_identifier _ -> true | _ -> false in 988 988 + (* Escaped reserved keywords (e.g., im\u0070ort) are an error, but 989 989 + strict-only reserved words are OK in non-strict mode *) 990 990 + if is_escaped then 991 991 + (match Token.keyword_of_string name with 992 992 + | Some kw when not (is_strict_reserved kw) -> error parser (Escaped_keyword name) 993 993 + | Some _ when parser.strict_mode -> error parser (Escaped_keyword name) 994 994 + | _ -> ()); 995 995 + if name = "yield" && parser.in_generator then 996 996 + error parser (Invalid_binding_identifier name); 997 997 + if name = "await" && (parser.in_async || parser.in_module || parser.in_static_block) then 998 998 + error parser (Invalid_binding_identifier name); 999 999 + if parser.strict_mode && is_strict_reserved_name name then 1000 1000 + error parser (Invalid_binding_identifier name); 1001 1001 + if parser.strict_mode && (name = "eval" || name = "arguments") then 1002 1002 + error parser (Strict_eval_arguments name); 291 1003 let loc = current_loc parser in 292 1004 advance parser; 293 1005 Ast.mk_pat ~loc (Ast.Pat_identifier { Ast.name; loc }) ··· 299 1011 advance parser; 300 1012 Ast.mk_pat ~loc (Ast.Pat_identifier { Ast.name; loc }) 301 1013 302 302 - (* 'await' can be identifier when not in async function and not in module *) 303 303 - | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module -> 1014 1014 + (* 'await' is syntactically valid as binding name; check semantics here *) 1015 1015 + | Token.Keyword Token.Kw_await -> 1016 1016 + if parser.in_async || parser.in_module || parser.in_static_block then 1017 1017 + error parser (Invalid_binding_identifier "await"); 304 1018 let loc = current_loc parser in 305 1019 advance parser; 306 1020 Ast.mk_pat ~loc (Ast.Pat_identifier { Ast.name = "await"; loc }) 307 1021 308 308 - (* 'yield' can be identifier when not in generator and not in strict mode *) 309 309 - | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode -> 1022 1022 + (* 'yield' is syntactically valid as binding name; check semantics here *) 1023 1023 + | Token.Keyword Token.Kw_yield -> 1024 1024 + if parser.in_generator || parser.strict_mode then 1025 1025 + error parser (Invalid_binding_identifier "yield"); 310 1026 let loc = current_loc parser in 311 1027 advance parser; 312 1028 Ast.mk_pat ~loc (Ast.Pat_identifier { Ast.name = "yield"; loc }) 313 1029 1030 1030 + (* 'let' can be identifier in non-strict mode (but will error as lexical binding name) *) 1031 1031 + | Token.Keyword Token.Kw_let when not parser.strict_mode -> 1032 1032 + let loc = current_loc parser in 1033 1033 + advance parser; 1034 1034 + Ast.mk_pat ~loc (Ast.Pat_identifier { Ast.name = "let"; loc }) 1035 1035 + 314 1036 | _ -> error parser Expected_identifier 315 1037 316 1038 and parse_function_params parser : Ast.pattern list = 317 1039 let params = ref [] in 1040 1040 + let rest_seen = ref false in 318 1041 while current_token parser <> Token.RParen && not (is_at_end parser) do 319 1042 if current_token parser = Token.Ellipsis then begin 1043 1043 + let loc = current_loc parser in 320 1044 advance parser; 321 1045 let pat = parse_binding_pattern parser in 322 322 - params := Ast.mk_pat ~loc:pat.loc (Ast.Pat_rest pat) :: !params 1046 1046 + params := Ast.mk_pat ~loc:pat.loc (Ast.Pat_rest pat) :: !params; 1047 1047 + rest_seen := true; 1048 1048 + (* Rest parameter must be last - check for trailing comma *) 1049 1049 + if current_token parser = Token.Comma then 1050 1050 + raise (Parse_error (Rest_parameter_last, loc)) 323 1051 end else begin 324 1052 let pat = parse_binding_pattern parser in 325 1053 let pat = ··· 337 1065 done; 338 1066 List.rev !params 339 1067 340 340 - and parse_function_body parser ~is_generator ~is_async : Ast.function_expression = 1068 1068 + and parse_function_body parser ~is_generator ~is_async ?(in_class=false) ?(in_method=false) ?(method_kind : Ast.method_kind option) ?(fn_name : Ast.identifier option) () : Ast.function_expression = 1069 1069 + (* Save and reset generator/async/static_block BEFORE parsing parameters, since yield/await 1070 1070 + should be based on THIS function's generator/async status, not the outer function's. 1071 1071 + Also set in_function/in_non_arrow_function for new.target to work in default params. 1072 1072 + Clear labels/iteration/switch since labeled break/continue can't cross function boundaries. *) 1073 1073 + let saved_in_static_block = parser.in_static_block in 1074 1074 + let saved_in_class_field_init = parser.in_class_field_init in 1075 1075 + let saved_super_call_forbidden = parser.super_call_forbidden in 1076 1076 + let saved_allow_super_property = parser.allow_super_property in 1077 1077 + let saved_in_generator = parser.in_generator in 1078 1078 + let saved_in_async = parser.in_async in 1079 1079 + let saved_in_function = parser.in_function in 1080 1080 + let saved_in_non_arrow_function = parser.in_non_arrow_function in 1081 1081 + let saved_in_formal_parameters = parser.in_formal_parameters in 1082 1082 + let saved_in_iteration = parser.in_iteration in 1083 1083 + let saved_in_switch = parser.in_switch in 1084 1084 + let saved_labels = parser.labels in 1085 1085 + let saved_iteration_labels = parser.iteration_labels in 1086 1086 + parser.in_static_block <- false; (* await is not reserved inside function parameters/bodies *) 1087 1087 + parser.in_class_field_init <- false; (* arguments is allowed inside function bodies *) 1088 1088 + parser.in_generator <- is_generator; (* yield keyword status depends on THIS function *) 1089 1089 + parser.in_async <- is_async; (* await keyword status depends on THIS function *) 1090 1090 + parser.in_function <- true; (* we're now inside a function (for default params) *) 1091 1091 + parser.in_non_arrow_function <- true; (* new.target is allowed in default params *) 1092 1092 + parser.in_formal_parameters <- true; (* Yield/await expressions forbidden in formal params *) 1093 1093 + parser.in_iteration <- false; (* break/continue without label not allowed *) 1094 1094 + parser.in_switch <- false; (* break without label not allowed *) 1095 1095 + parser.labels <- []; (* labels from outside can't be break/continue targets *) 1096 1096 + parser.iteration_labels <- []; 1097 1097 + (* super() is only allowed in constructors - forbidden everywhere else *) 1098 1098 + parser.super_call_forbidden <- (match method_kind with 1099 1099 + | Some Ast.Constructor -> false (* Constructor can have super() *) 1100 1100 + | _ -> true); (* All other functions: super() is forbidden *) 1101 1101 + (* super.x is allowed in class methods and object methods *) 1102 1102 + if in_class || in_method then parser.allow_super_property <- true; 341 1103 expect parser Token.LParen; 1104 1104 + let params_start_loc = current_loc parser in 342 1105 let params = parse_function_params parser in 1106 1106 + (* Check for rest parameter not at end *) 1107 1107 + if has_rest_before_end params then 1108 1108 + raise (Parse_error (Rest_parameter_last, params_start_loc)); 1109 1109 + (* Check getter/setter parameter counts *) 1110 1110 + (match method_kind with 1111 1111 + | Some Ast.Get_method when List.length params > 0 -> 1112 1112 + raise (Parse_error (Getter_with_parameters, params_start_loc)) 1113 1113 + | Some Ast.Set_method when List.length params <> 1 -> 1114 1114 + raise (Parse_error (Setter_wrong_param_count, params_start_loc)) 1115 1115 + | _ -> ()); 343 1116 expect parser Token.RParen; 344 344 - expect parser Token.LBrace; 345 345 - let saved_in_function = parser.in_function in 346 346 - let saved_in_generator = parser.in_generator in 347 347 - let saved_in_async = parser.in_async in 1117 1117 + (* Done with formal parameters, reset the flag before parsing the body *) 1118 1118 + parser.in_formal_parameters <- saved_in_formal_parameters; 1119 1119 + (* Check and consume opening brace, then set up for prescan. 1120 1120 + We need to save lexer state BEFORE lexing the first body token 1121 1121 + so we can restore and re-lex with strict mode if "use strict" is found. *) 1122 1122 + if current_token parser <> Token.LBrace then 1123 1123 + error parser (Expected_token (Token.show Token.LBrace, current_token parser)); 1124 1124 + (* Save lexer state BEFORE advancing - cursor is right after '{' *) 1125 1125 + let saved_lexer_for_prescan = Lexer.save parser.lexer in 1126 1126 + advance parser; (* Now parser.current has first body token *) 1127 1127 + (* Push function scope for redeclaration detection *) 1128 1128 + push_scope parser ~is_function:true; 1129 1129 + (* Add parameter bindings to the function scope so they conflict with body let/const. 1130 1130 + We add directly to the scope without using add_binding because: 1131 1131 + 1. Duplicate parameters are handled separately in check_duplicate_params 1132 1132 + 2. In non-strict mode with simple params, duplicate params are allowed *) 1133 1133 + let scope = current_scope parser in 1134 1134 + List.iter (fun pat -> 1135 1135 + List.iter (fun (name, loc) -> 1136 1136 + Hashtbl.replace scope.scope_bindings name { bind_name = name; bind_kind = Bind_param; bind_loc = loc } 1137 1137 + ) (collect_bound_names_from_pattern pat) 1138 1138 + ) params; 348 1139 let saved_strict_mode = parser.strict_mode in 349 349 - parser.in_function <- true; 350 350 - parser.in_generator <- is_generator; 351 351 - parser.in_async <- is_async; 1140 1140 + (* Class methods are always strict mode *) 1141 1141 + if in_class then begin 1142 1142 + parser.strict_mode <- true; 1143 1143 + Lexer.set_strict_mode parser.lexer true 1144 1144 + end; 1145 1145 + (* Pre-scan for "use strict" directive BEFORE parsing to ensure strings with 1146 1146 + octal escapes are properly rejected. This is required by the spec. 1147 1147 + The prescan function sets strict mode on both parser and lexer if found, 1148 1148 + and re-lexes the current token to catch octal escapes. 1149 1149 + We always check for "use strict" even in class methods (which are already strict) 1150 1150 + because the spec requires rejecting "use strict" + non-simple params as a syntax error. *) 1151 1151 + let has_use_strict = prescan_for_use_strict parser saved_lexer_for_prescan in 352 1152 let start_loc = current_loc parser in 353 1153 let stmts = ref [] in 354 1154 let directives = ref [] in 355 1155 let parsing_directives = ref true in 356 356 - while current_token parser <> Token.RBrace && not (is_at_end parser) do 357 357 - let s = parse_statement parser in 358 358 - if !parsing_directives then begin 359 359 - match s.Ast.stmt with 360 360 - | Ast.Expression { Ast.expr = Ast.Literal (Ast.Lit_string str); _ } -> 361 361 - directives := str :: !directives; 362 362 - if str = "use strict" then parser.strict_mode <- true 363 363 - | _ -> parsing_directives := false 1156 1156 + (try 1157 1157 + while current_token parser <> Token.RBrace && not (is_at_end parser) do 1158 1158 + let s = parse_statement parser in 1159 1159 + if !parsing_directives then begin 1160 1160 + match s.Ast.stmt with 1161 1161 + | Ast.Expression { Ast.expr = Ast.Literal (Ast.Lit_string str); _ } -> 1162 1162 + directives := str :: !directives; 1163 1163 + (* "use strict" already detected in pre-scan *) 1164 1164 + () 1165 1165 + | _ -> parsing_directives := false 1166 1166 + end; 1167 1167 + stmts := s :: !stmts 1168 1168 + done; 1169 1169 + (* Check for "use strict" with non-simple parameters *) 1170 1170 + if has_use_strict && not (is_simple_parameter_list params) then 1171 1171 + raise (Parse_error (Use_strict_non_simple_params, start_loc)); 1172 1172 + (* Check for eval/arguments as parameter names in strict mode (including from "use strict" in body) *) 1173 1173 + if parser.strict_mode then begin 1174 1174 + let param_names = List.concat_map collect_bound_names_from_pattern params in 1175 1175 + List.iter (fun (name, loc) -> 1176 1176 + if name = "eval" || name = "arguments" then 1177 1177 + raise (Parse_error (Strict_eval_arguments name, loc)) 1178 1178 + ) param_names 364 1179 end; 365 365 - stmts := s :: !stmts 366 366 - done; 1180 1180 + (* Check for eval/arguments as function name in strict mode (including from "use strict" in body) *) 1181 1181 + (match fn_name with 1182 1182 + | Some { Ast.name; loc } when parser.strict_mode && (name = "eval" || name = "arguments") -> 1183 1183 + raise (Parse_error (Strict_eval_arguments name, loc)) 1184 1184 + | _ -> ()); 1185 1185 + (* Check for duplicate parameters in strict mode, non-simple parameters, or methods. 1186 1186 + Methods use UniqueFormalParameters per spec, so duplicates are always forbidden. *) 1187 1187 + if parser.strict_mode || in_class || in_method || not (is_simple_parameter_list params) then 1188 1188 + check_duplicate_params parser params 1189 1189 + with e -> 1190 1190 + pop_scope parser; 1191 1191 + raise e); 1192 1192 + pop_scope parser; 367 1193 let end_loc = current_loc parser in 368 1194 expect parser Token.RBrace; 369 1195 parser.in_function <- saved_in_function; 1196 1196 + parser.in_non_arrow_function <- saved_in_non_arrow_function; 370 1197 parser.in_generator <- saved_in_generator; 371 1198 parser.in_async <- saved_in_async; 372 1199 parser.strict_mode <- saved_strict_mode; 1200 1200 + parser.in_static_block <- saved_in_static_block; 1201 1201 + parser.in_class_field_init <- saved_in_class_field_init; 1202 1202 + parser.super_call_forbidden <- saved_super_call_forbidden; 1203 1203 + parser.allow_super_property <- saved_allow_super_property; 1204 1204 + parser.in_iteration <- saved_in_iteration; 1205 1205 + parser.in_switch <- saved_in_switch; 1206 1206 + parser.labels <- saved_labels; 1207 1207 + parser.iteration_labels <- saved_iteration_labels; 373 1208 let body_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 374 1209 { 375 1210 Ast.fn_id = None; ··· 390 1225 let arg = parse_assignment_expression parser in 391 1226 Ast.Spread_element arg 392 1227 end else begin 393 393 - (* Check for async keyword *) 1228 1228 + (* Check for async keyword - must not contain escapes *) 394 1229 let is_async = 395 395 - match current_token parser with 396 396 - | Token.Identifier "async" when not (Lexer.peek parser.lexer).preceded_by_newline -> 1230 1230 + match is_contextual_token (current_token parser) "async" with 1231 1231 + | Some escaped when not (Lexer.peek parser.lexer).preceded_by_newline -> 397 1232 let next = Lexer.peek parser.lexer in 398 398 - (* async is a method prefix only if followed by method name, not colon or paren *) 399 399 - if next.tok <> Token.Colon && next.tok <> Token.LParen then begin 1233 1233 + (* async is a method prefix only if followed by method name, not: 1234 1234 + - colon (async: value) 1235 1235 + - lparen (async() method - non-async) 1236 1236 + - comma ({async, other} shorthand) 1237 1237 + - rbrace ({async} shorthand) *) 1238 1238 + if next.tok <> Token.Colon && next.tok <> Token.LParen && next.tok <> Token.Comma && next.tok <> Token.RBrace then begin 1239 1239 + if escaped then error parser (Escaped_contextual_keyword "async"); 400 1240 advance parser; 401 1241 true 402 1242 end else false ··· 411 1251 in 412 1252 let kind = 413 1253 match current_token parser with 414 414 - | Token.Identifier "get" when not is_generator && not is_async -> 1254 1254 + | (Token.Identifier "get" | Token.Escaped_identifier "get") when not is_generator && not is_async -> 415 1255 let next = Lexer.peek parser.lexer in 416 416 - if next.tok <> Token.Colon && next.tok <> Token.LParen then begin 1256 1256 + (* get is a getter prefix unless followed by: 1257 1257 + - colon (get: value) 1258 1258 + - lparen (get() method) 1259 1259 + - comma (get, shorthand) 1260 1260 + - rbrace ({get} shorthand) *) 1261 1261 + if next.tok <> Token.Colon && next.tok <> Token.LParen && next.tok <> Token.Comma && next.tok <> Token.RBrace then begin 1262 1262 + (match current_token parser with 1263 1263 + | Token.Escaped_identifier _ -> error parser (Escaped_contextual_keyword "get") 1264 1264 + | _ -> ()); 417 1265 advance parser; Ast.Get 418 1266 end else Ast.Init 419 419 - | Token.Identifier "set" when not is_generator && not is_async -> 1267 1267 + | (Token.Identifier "set" | Token.Escaped_identifier "set") when not is_generator && not is_async -> 420 1268 let next = Lexer.peek parser.lexer in 421 421 - if next.tok <> Token.Colon && next.tok <> Token.LParen then begin 1269 1269 + (* set is a setter prefix unless followed by: 1270 1270 + - colon (set: value) 1271 1271 + - lparen (set() method) 1272 1272 + - comma (set, shorthand) 1273 1273 + - rbrace ({set} shorthand) *) 1274 1274 + if next.tok <> Token.Colon && next.tok <> Token.LParen && next.tok <> Token.Comma && next.tok <> Token.RBrace then begin 1275 1275 + (match current_token parser with 1276 1276 + | Token.Escaped_identifier _ -> error parser (Escaped_contextual_keyword "set") 1277 1277 + | _ -> ()); 422 1278 advance parser; Ast.Set 423 1279 end else Ast.Init 424 1280 | _ -> Ast.Init 425 1281 in 426 1282 let computed = current_token parser = Token.LBracket in 1283 1283 + let escaped_strict_reserved = ref None in (* Track escaped strict reserved word for shorthand validation *) 427 1284 let key = 428 1285 if computed then begin 429 1286 advance parser; ··· 436 1293 k 437 1294 end else begin 438 1295 match current_token parser with 439 439 - | Token.Identifier name -> 1296 1296 + | Token.Identifier name | Token.Escaped_identifier name -> 1297 1297 + (* Track escaped identifiers for shorthand validation. 1298 1298 + Property names can be any identifier/keyword, but shorthand properties 1299 1299 + use the name as an identifier reference, so escaped keywords are an error. *) 1300 1300 + let is_escaped = match current_token parser with Token.Escaped_identifier _ -> true | _ -> false in 1301 1301 + if is_escaped then begin 1302 1302 + match Token.keyword_of_string name with 1303 1303 + | Some _ -> escaped_strict_reserved := Some name (* Track escaped keyword *) 1304 1304 + | None -> 1305 1305 + if is_strict_reserved_name name then 1306 1306 + escaped_strict_reserved := Some name (* Track escaped strict reserved *) 1307 1307 + end; 440 1308 let loc = current_loc parser in 441 1309 advance parser; 442 1310 Ast.mk_expr ~loc (Ast.Literal (Ast.Lit_string name)) ··· 462 1330 in 463 1331 match current_token parser with 464 1332 | Token.LParen -> 465 465 - let fn = parse_function_body parser ~is_generator ~is_async in 1333 1333 + (* Map property kind to method kind for validation *) 1334 1334 + let method_kind = match kind with 1335 1335 + | Ast.Get -> Some Ast.Get_method 1336 1336 + | Ast.Set -> Some Ast.Set_method 1337 1337 + | Ast.Init -> None 1338 1338 + in 1339 1339 + let fn = parse_function_body parser ~is_generator ~is_async ~in_method:true ?method_kind () in 466 1340 let end_loc = current_loc parser in 467 1341 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 468 1342 let value = Ast.mk_expr ~loc (Ast.Function fn) in ··· 476 1350 | Ast.Literal (Ast.Lit_string s) -> s 477 1351 | _ -> error parser Expected_identifier 478 1352 in 1353 1353 + (* Shorthand property names must be valid identifier references. 1354 1354 + Reserved words like 'this', 'super', 'true', 'false', 'null' are not allowed. 1355 1355 + But yield/await can be identifiers in certain contexts. *) 1356 1356 + (match Token.keyword_of_string name with 1357 1357 + | Some Token.Kw_yield -> 1358 1358 + (* yield is reserved inside generators or in strict mode *) 1359 1359 + if parser.in_generator || parser.strict_mode then 1360 1360 + error parser (Invalid_binding_identifier "yield") 1361 1361 + | Some Token.Kw_await -> 1362 1362 + (* await is only reserved inside async functions, modules, or static blocks *) 1363 1363 + if parser.in_async || parser.in_module || parser.in_static_block then 1364 1364 + error parser (Invalid_binding_identifier "await") 1365 1365 + | Some kw when not (is_strict_reserved kw) && not (is_contextual_keyword kw) -> 1366 1366 + error parser (Unexpected_token (Token.Keyword kw)) 1367 1367 + | _ -> ()); 1368 1368 + (* Check for strict reserved word used as shorthand identifier *) 1369 1369 + if parser.strict_mode && is_strict_reserved_name name then 1370 1370 + error parser (Strict_reserved_word name); 1371 1371 + (* Check for escaped keyword/reserved word used as shorthand identifier *) 1372 1372 + (match !escaped_strict_reserved with 1373 1373 + | Some n when n = name -> 1374 1374 + (* Escaped true keywords are always an error; strict-only reserved words 1375 1375 + are only an error in strict mode *) 1376 1376 + (match Token.keyword_of_string n with 1377 1377 + | Some kw when not (is_strict_reserved kw) -> error parser (Escaped_keyword name) 1378 1378 + | Some _ when parser.strict_mode -> error parser (Escaped_keyword name) 1379 1379 + | None when parser.strict_mode -> error parser (Strict_reserved_word name) 1380 1380 + | _ -> ()) 1381 1381 + | _ -> ()); 479 1382 let ident_expr = Ast.mk_expr ~loc:key.loc (Ast.Identifier { Ast.name; loc = key.loc }) in 480 1383 (* Check for shorthand with default value: { x = 1 } *) 481 1384 let value = ··· 498 1401 let saved_allow_in = parser.allow_in in 499 1402 parser.allow_in <- true; 500 1403 let elements = ref [] in 1404 1404 + let has_spread = ref false in (* Track if we've seen a spread for trailing comma validation *) 501 1405 while current_token parser <> Token.RBracket && not (is_at_end parser) do 502 1406 if current_token parser = Token.Comma then begin 503 1407 elements := None :: !elements; ··· 507 1411 if current_token parser = Token.Ellipsis then begin 508 1412 advance parser; 509 1413 let arg = parse_assignment_expression parser in 1414 1414 + has_spread := true; 510 1415 Ast.mk_expr ~loc:arg.loc (Ast.Spread arg) 511 511 - end else 1416 1416 + end else begin 1417 1417 + has_spread := false; (* Reset - only last spread matters *) 512 1418 parse_assignment_expression parser 1419 1419 + end 513 1420 in 514 1421 elements := Some elem :: !elements; 515 515 - if current_token parser <> Token.RBracket then 516 516 - expect parser Token.Comma 1422 1422 + if current_token parser <> Token.RBracket then begin 1423 1423 + expect parser Token.Comma; 1424 1424 + (* Trailing comma after spread creates an elision - record it *) 1425 1425 + if !has_spread && current_token parser = Token.RBracket then 1426 1426 + elements := None :: !elements (* Add elision for trailing comma after spread *) 1427 1427 + end 517 1428 end 518 1429 done; 519 1430 parser.allow_in <- saved_allow_in; ··· 568 1479 Ast.mk_expr ~loc Ast.This 569 1480 570 1481 | Token.Keyword Token.Kw_super -> 1482 1482 + if not parser.allow_super_property then 1483 1483 + error parser Super_outside_method; 571 1484 advance parser; 572 1485 Ast.mk_expr ~loc Ast.Super 573 1486 ··· 580 1493 if is_generator then advance parser; 581 1494 let fn_id = 582 1495 match current_token parser with 583 583 - | Token.Identifier _ -> Some (parse_identifier parser) 1496 1496 + | Token.Identifier _ | Token.Escaped_identifier _ -> Some (parse_identifier parser) 584 1497 | _ -> None 585 1498 in 586 586 - let fn = parse_function_body parser ~is_generator ~is_async:true in 1499 1499 + (* In strict mode, 'eval' and 'arguments' are not allowed as function names *) 1500 1500 + (match fn_id with 1501 1501 + | Some id when parser.strict_mode && (id.name = "eval" || id.name = "arguments") -> 1502 1502 + error parser (Strict_eval_arguments id.name) 1503 1503 + | _ -> ()); 1504 1504 + let fn = parse_function_body parser ~is_generator ~is_async:true ?fn_name:fn_id () in 587 1505 let end_loc = current_loc parser in 588 1506 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 589 1507 Ast.mk_expr ~loc (Ast.Function { fn with fn_id }) 590 1508 591 591 - | Token.Identifier name -> 1509 1509 + | Token.Identifier name | Token.Escaped_identifier name -> 1510 1510 + (* Check if identifier name is a reserved word (catches escaped keywords) *) 1511 1511 + let is_escaped = match current_token parser with Token.Escaped_identifier _ -> true | _ -> false in 1512 1512 + (* Escaped reserved keywords (e.g., im\u0070ort) are an error, but 1513 1513 + strict-only reserved words are OK in non-strict mode *) 1514 1514 + if is_escaped then 1515 1515 + (match Token.keyword_of_string name with 1516 1516 + | Some kw when not (is_strict_reserved kw) -> error parser (Escaped_keyword name) 1517 1517 + | Some _ when parser.strict_mode -> error parser (Escaped_keyword name) 1518 1518 + | _ -> ()); 1519 1519 + if name = "yield" && parser.in_generator then 1520 1520 + error parser (Invalid_binding_identifier name); 1521 1521 + if name = "await" && (parser.in_async || parser.in_module || parser.in_static_block) then 1522 1522 + error parser (Invalid_binding_identifier name); 1523 1523 + if parser.strict_mode && is_strict_reserved_name name then 1524 1524 + error parser (Invalid_binding_identifier name); 1525 1525 + (* 'arguments' is not allowed in class field initializers or static blocks *) 1526 1526 + if name = "arguments" && (parser.in_class_field_init || parser.in_static_block) then 1527 1527 + error parser Arguments_in_class_field; 592 1528 advance parser; 593 1529 Ast.mk_expr ~loc (Ast.Identifier { Ast.name; loc }) 594 1530 ··· 604 1540 advance parser; 605 1541 Ast.mk_expr ~loc (Ast.Identifier { Ast.name; loc }) 606 1542 607 607 - (* 'await' can be identifier when not in async function and not in module *) 608 608 - | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module -> 1543 1543 + (* 'await' can be identifier when not in async function, not in module, and not in static block *) 1544 1544 + | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module && not parser.in_static_block -> 1545 1545 + (* When await is used as identifier, / should be division not regexp *) 1546 1546 + Lexer.set_allow_regexp parser.lexer false; 609 1547 advance parser; 610 1548 Ast.mk_expr ~loc (Ast.Identifier { Ast.name = "await"; loc }) 611 1549 612 1550 (* 'yield' can be identifier when not in generator and not in strict mode *) 613 1551 | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode -> 1552 1552 + (* When yield is used as identifier, / should be division not regexp *) 1553 1553 + Lexer.set_allow_regexp parser.lexer false; 614 1554 advance parser; 615 1555 Ast.mk_expr ~loc (Ast.Identifier { Ast.name = "yield"; loc }) 616 1556 617 617 - (* Private identifier *) 1557 1557 + (* Private identifier - used for #x in obj checks *) 618 1558 | Token.Private_identifier name -> 619 1559 advance parser; 1560 1560 + (* Record this private name reference for later validation *) 1561 1561 + record_private_name_ref parser name loc; 620 1562 Ast.mk_expr ~loc (Ast.Private_identifier name) 621 1563 622 1564 | Token.Keyword Token.Kw_null ··· 647 1589 advance parser; 648 1590 let is_generator = current_token parser = Token.Star in 649 1591 if is_generator then advance parser; 1592 1592 + (* For function expression names, temporarily allow yield/await as identifiers 1593 1593 + since the inner function creates a new scope *) 1594 1594 + let saved_in_generator = parser.in_generator in 1595 1595 + let saved_in_async = parser.in_async in 1596 1596 + let saved_in_static_block = parser.in_static_block in 1597 1597 + if not is_generator then parser.in_generator <- false; 1598 1598 + parser.in_async <- false; (* Function expression is not async at name parsing time *) 1599 1599 + parser.in_static_block <- false; (* Function expression is not in static block context *) 650 1600 let fn_id = 651 1601 match current_token parser with 652 652 - | Token.Identifier _ -> Some (parse_identifier parser) 1602 1602 + | Token.Identifier _ | Token.Escaped_identifier _ -> Some (parse_identifier parser) 1603 1603 + | Token.Keyword Token.Kw_yield when not is_generator && not parser.strict_mode -> 1604 1604 + let loc = current_loc parser in 1605 1605 + advance parser; 1606 1606 + Some { Ast.name = "yield"; loc } 1607 1607 + | Token.Keyword Token.Kw_await when not parser.in_module -> 1608 1608 + let loc = current_loc parser in 1609 1609 + advance parser; 1610 1610 + Some { Ast.name = "await"; loc } 653 1611 | _ -> None 654 1612 in 655 655 - let fn = parse_function_body parser ~is_generator ~is_async:false in 1613 1613 + (* In strict mode, 'eval' and 'arguments' are not allowed as function names *) 1614 1614 + (match fn_id with 1615 1615 + | Some id when parser.strict_mode && (id.name = "eval" || id.name = "arguments") -> 1616 1616 + error parser (Strict_eval_arguments id.name) 1617 1617 + | _ -> ()); 1618 1618 + parser.in_generator <- saved_in_generator; 1619 1619 + parser.in_async <- saved_in_async; 1620 1620 + parser.in_static_block <- saved_in_static_block; 1621 1621 + let fn = parse_function_body parser ~is_generator ~is_async:false ?fn_name:fn_id () in 656 1622 let end_loc = current_loc parser in 657 1623 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 658 1624 Ast.mk_expr ~loc (Ast.Function { fn with fn_id }) ··· 664 1630 if current_token parser = Token.Dot then begin 665 1631 advance parser; 666 1632 match current_token parser with 1633 1633 + | Token.Escaped_identifier "target" -> 1634 1634 + (* 'target' keyword must not contain escape sequences *) 1635 1635 + error parser (Escaped_contextual_keyword "target") 667 1636 | Token.Identifier "target" | Token.Keyword Token.Kw_target -> 1637 1637 + if not parser.in_non_arrow_function then 1638 1638 + error parser New_target_outside_function; 668 1639 let end_loc = current_loc parser in 669 1640 advance parser; 670 1641 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in ··· 673 1644 Ast.mk_expr ~loc (Ast.Meta_property { meta; property }) 674 1645 | _ -> error parser Expected_identifier 675 1646 end else begin 1647 1647 + (* Check for 'new import(...)' which is illegal - import() is a CallExpression not MemberExpression. 1648 1648 + Also check for 'new import.source(...)' and 'new import.defer(...)' which are also CallExpressions. *) 1649 1649 + if current_token parser = Token.Keyword Token.Kw_import then begin 1650 1650 + let next = Lexer.peek parser.lexer in 1651 1651 + if next.tok = Token.LParen then 1652 1652 + error parser Cannot_use_new_with_import 1653 1653 + else if next.tok = Token.Dot then begin 1654 1654 + (* Check if it's import.source or import.defer - these are CallExpressions, not constructors *) 1655 1655 + let next2 = Lexer.peek2 parser.lexer in 1656 1656 + match next2.tok with 1657 1657 + | Token.Identifier "source" | Token.Identifier "defer" -> 1658 1658 + (* Check if followed by ( - if so, it's a call expression and new is illegal *) 1659 1659 + let next3 = Lexer.peek3 parser.lexer in 1660 1660 + if next3.tok = Token.LParen then 1661 1661 + error parser Cannot_use_new_with_import 1662 1662 + | _ -> () 1663 1663 + end 1664 1664 + end; 676 1665 let callee = parse_member_expression parser in 1666 1666 + (* Check if the callee is an import() expression (shouldn't happen but just in case) *) 1667 1667 + (match callee.Ast.expr with 1668 1668 + | Ast.Import _ -> error parser Cannot_use_new_with_import 1669 1669 + | _ -> ()); 677 1670 let arguments = 678 1671 if current_token parser = Token.LParen then 679 1672 parse_arguments parser ··· 685 1678 Ast.mk_expr ~loc (Ast.New { callee; arguments }) 686 1679 end 687 1680 688 688 - (* Template literals *) 689 689 - | Token.Template (Token.Template_no_sub raw) -> 1681 1681 + (* Template literals - untagged templates don't allow invalid escapes *) 1682 1682 + | Token.Template (Token.Template_no_sub { raw; cooked }) -> 1683 1683 + (* Check for invalid escape - untagged templates require valid cooked value *) 1684 1684 + if cooked = None then error parser Invalid_template_escape; 690 1685 advance parser; 691 691 - let cooked = Some raw in (* Simplified - should decode escapes *) 692 1686 let quasi = { 693 1687 Ast.quasis = [{ Ast.raw; cooked; tail = true }]; 694 1688 expressions = []; 695 1689 } in 696 1690 Ast.mk_expr ~loc (Ast.Template quasi) 697 1691 698 698 - | Token.Template (Token.Template_head raw) -> 1692 1692 + | Token.Template (Token.Template_head { raw; cooked }) -> 1693 1693 + (* Check for invalid escape - untagged templates require valid cooked value *) 1694 1694 + if cooked = None then error parser Invalid_template_escape; 699 1695 let start_loc = current_loc parser in 700 1696 advance parser; 701 701 - let quasis = ref [{ Ast.raw; cooked = Some raw; tail = false }] in 1697 1697 + let quasis = ref [{ Ast.raw; cooked; tail = false }] in 702 1698 let expressions = ref [] in 703 1699 let rec parse_template_rest () = 704 1700 let expr = parse_expression parser in ··· 706 1702 let tail_tok = Lexer.scan_template_tail parser.lexer in 707 1703 parser.current <- tail_tok; 708 1704 match tail_tok.tok with 709 709 - | Token.Template (Token.Template_tail raw) -> 710 710 - quasis := { Ast.raw; cooked = Some raw; tail = true } :: !quasis; 1705 1705 + | Token.Template (Token.Template_tail { raw; cooked }) -> 1706 1706 + (* Check for invalid escape in tail *) 1707 1707 + if cooked = None then error parser Invalid_template_escape; 1708 1708 + quasis := { Ast.raw; cooked; tail = true } :: !quasis; 711 1709 advance parser 712 712 - | Token.Template (Token.Template_middle raw) -> 713 713 - quasis := { Ast.raw; cooked = Some raw; tail = false } :: !quasis; 1710 1710 + | Token.Template (Token.Template_middle { raw; cooked }) -> 1711 1711 + (* Check for invalid escape in middle *) 1712 1712 + if cooked = None then error parser Invalid_template_escape; 1713 1713 + quasis := { Ast.raw; cooked; tail = false } :: !quasis; 714 1714 advance parser; 715 1715 parse_template_rest () 716 1716 | _ -> error parser (Expected_token ("}", current_token parser)) ··· 734 1734 advance parser; 735 1735 (match current_token parser with 736 1736 | Token.Identifier "meta" | Token.Keyword Token.Kw_meta -> 1737 1737 + (* import.meta is only allowed in modules *) 1738 1738 + if not parser.in_module then 1739 1739 + error parser Import_export_in_script; 737 1740 let end_loc = current_loc parser in 738 1741 advance parser; 739 1742 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in ··· 741 1744 let property = { Ast.name = "meta"; loc = end_loc } in 742 1745 Ast.mk_expr ~loc (Ast.Meta_property { meta; property }) 743 1746 | Token.Identifier "source" -> 744 744 - (* import.source(specifier) - source phase import *) 1747 1747 + (* import.source(specifier) - source phase import. 1748 1748 + Unlike import.meta, import.source MUST be called immediately. 1749 1749 + import.source without () is a syntax error. *) 745 1750 let source_loc = current_loc parser in 746 1751 advance parser; 1752 1752 + (* Must be followed by ( *) 1753 1753 + if current_token parser <> Token.LParen then 1754 1754 + error parser (Expected_token ("(", current_token parser)); 1755 1755 + advance parser; 1756 1756 + let saved_allow_in = parser.allow_in in 1757 1757 + parser.allow_in <- true; 1758 1758 + let arg = parse_assignment_expression parser in 1759 1759 + parser.allow_in <- saved_allow_in; 1760 1760 + expect parser Token.RParen; 1761 1761 + let end_loc = current_loc parser in 1762 1762 + let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 1763 1763 + (* Represent as a special Import_source node or reuse Import with source flag *) 747 1764 let meta = { Ast.name = "import"; loc = start_loc } in 748 1765 let property = { Ast.name = "source"; loc = source_loc } in 749 749 - let loc = Source.mk_loc ~start:start_loc.start ~end_:source_loc.end_ () in 750 750 - Ast.mk_expr ~loc (Ast.Meta_property { meta; property }) 1766 1766 + (* For now, represent as Call of Meta_property *) 1767 1767 + let callee_loc = Source.mk_loc ~start:start_loc.start ~end_:source_loc.end_ () in 1768 1768 + let callee = Ast.mk_expr ~loc:callee_loc (Ast.Meta_property { meta; property }) in 1769 1769 + Ast.mk_expr ~loc (Ast.Call { callee; arguments = [arg]; optional = false }) 751 1770 | Token.Identifier "defer" -> 752 752 - (* import.defer(specifier) - deferred import evaluation *) 1771 1771 + (* import.defer(specifier) - deferred import evaluation. 1772 1772 + Like import.source, must be called immediately. *) 753 1773 let defer_loc = current_loc parser in 754 1774 advance parser; 1775 1775 + (* Must be followed by ( *) 1776 1776 + if current_token parser <> Token.LParen then 1777 1777 + error parser (Expected_token ("(", current_token parser)); 1778 1778 + advance parser; 1779 1779 + let saved_allow_in = parser.allow_in in 1780 1780 + parser.allow_in <- true; 1781 1781 + let arg = parse_assignment_expression parser in 1782 1782 + parser.allow_in <- saved_allow_in; 1783 1783 + expect parser Token.RParen; 1784 1784 + let end_loc = current_loc parser in 1785 1785 + let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 755 1786 let meta = { Ast.name = "import"; loc = start_loc } in 756 1787 let property = { Ast.name = "defer"; loc = defer_loc } in 757 757 - let loc = Source.mk_loc ~start:start_loc.start ~end_:defer_loc.end_ () in 758 758 - Ast.mk_expr ~loc (Ast.Meta_property { meta; property }) 1788 1788 + let callee_loc = Source.mk_loc ~start:start_loc.start ~end_:defer_loc.end_ () in 1789 1789 + let callee = Ast.mk_expr ~loc:callee_loc (Ast.Meta_property { meta; property }) in 1790 1790 + Ast.mk_expr ~loc (Ast.Call { callee; arguments = [arg]; optional = false }) 759 1791 | _ -> error parser Expected_identifier) 760 1792 | Token.LParen -> 761 1793 (* import("module") or import("module", options) *) ··· 791 1823 advance parser; 792 1824 let cls_id = 793 1825 match current_token parser with 794 794 - | Token.Identifier _ -> Some (parse_identifier parser) 1826 1826 + | Token.Identifier _ | Token.Escaped_identifier _ -> Some (parse_class_name parser) 1827 1827 + | Token.Keyword kw when is_contextual_keyword kw -> Some (parse_class_name parser) 1828 1828 + | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode -> Some (parse_class_name parser) 1829 1829 + | Token.Keyword Token.Kw_await when not parser.in_module && not parser.in_async && not parser.in_static_block -> Some (parse_class_name parser) 1830 1830 + | Token.Keyword kw when is_strict_reserved kw -> 1831 1831 + error parser (Invalid_class_name (Token.keyword_to_string kw)) 795 1832 | _ -> None 796 1833 in 1834 1834 + (* Class code is always strict mode *) 1835 1835 + let saved_strict_mode = parser.strict_mode in 1836 1836 + parser.strict_mode <- true; 797 1837 let cls_super = 798 1838 if current_token parser = Token.Keyword Token.Kw_extends then begin 799 1839 advance parser; ··· 801 1841 end else 802 1842 None 803 1843 in 1844 1844 + let saved_in_derived_class = parser.in_derived_class in 1845 1845 + parser.in_derived_class <- cls_super <> None; 804 1846 let cls_body = parse_class_body parser in 1847 1847 + parser.in_derived_class <- saved_in_derived_class; 1848 1848 + parser.strict_mode <- saved_strict_mode; 805 1849 let end_loc = current_loc parser in 806 1850 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 807 1851 Ast.mk_expr ~loc (Ast.Class { cls_id; cls_super; cls_body; cls_decorators = decorators }) ··· 812 1856 advance parser; 813 1857 let cls_id = 814 1858 match current_token parser with 815 815 - | Token.Identifier _ -> Some (parse_identifier parser) 1859 1859 + | Token.Identifier _ | Token.Escaped_identifier _ -> Some (parse_class_name parser) 1860 1860 + | Token.Keyword kw when is_contextual_keyword kw -> Some (parse_class_name parser) 1861 1861 + | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode -> Some (parse_class_name parser) 1862 1862 + | Token.Keyword Token.Kw_await when not parser.in_module && not parser.in_async && not parser.in_static_block -> Some (parse_class_name parser) 1863 1863 + | Token.Keyword kw when is_strict_reserved kw -> 1864 1864 + error parser (Invalid_class_name (Token.keyword_to_string kw)) 816 1865 | _ -> None 817 1866 in 1867 1867 + (* Class code is always strict mode *) 1868 1868 + let saved_strict_mode = parser.strict_mode in 1869 1869 + parser.strict_mode <- true; 818 1870 let cls_super = 819 1871 if current_token parser = Token.Keyword Token.Kw_extends then begin 820 1872 advance parser; ··· 822 1874 end else 823 1875 None 824 1876 in 1877 1877 + let saved_in_derived_class = parser.in_derived_class in 1878 1878 + parser.in_derived_class <- cls_super <> None; 825 1879 let cls_body = parse_class_body parser in 1880 1880 + parser.in_derived_class <- saved_in_derived_class; 1881 1881 + parser.strict_mode <- saved_strict_mode; 826 1882 let end_loc = current_loc parser in 827 1883 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 828 1884 Ast.mk_expr ~loc (Ast.Class { cls_id; cls_super; cls_body; cls_decorators = [] }) ··· 833 1889 let start_loc = current_loc parser in 834 1890 expect parser Token.LBrace; 835 1891 let elements = ref [] in 1892 1892 + (* Track if we've seen a constructor *) 1893 1893 + let has_constructor = ref false in 1894 1894 + (* Push a new private name scope for this class *) 1895 1895 + let new_scope = { declared = []; pending = [] } in 1896 1896 + parser.private_name_scopes <- new_scope :: parser.private_name_scopes; 1897 1897 + (* Track private names for duplicate detection *) 1898 1898 + (* Each entry is (name, kind, static) where kind is `Field | `Method | `Getter | `Setter *) 1899 1899 + let private_names : (string * [`Field | `Method | `Getter | `Setter] * bool) list ref = ref [] in 1900 1900 + (* Helper to add a private name to the current scope *) 1901 1901 + let add_private_to_scope name = 1902 1902 + match parser.private_name_scopes with 1903 1903 + | scope :: _ -> scope.declared <- name :: scope.declared 1904 1904 + | [] -> () (* Should not happen *) 1905 1905 + in 1906 1906 + let check_private_name name kind is_static = 1907 1907 + (* Check for conflicts with existing private names of the same static-ness *) 1908 1908 + let same_static = List.filter (fun (n, _, s) -> n = name && s = is_static) !private_names in 1909 1909 + List.iter (fun (_, existing_kind, _) -> 1910 1910 + match existing_kind, kind with 1911 1911 + | `Getter, `Setter | `Setter, `Getter -> () (* getter+setter pair is OK *) 1912 1912 + | _ -> error parser (Duplicate_private_name name) 1913 1913 + ) same_static; 1914 1914 + (* Check for conflicts with existing private names of different static-ness. 1915 1915 + Per spec, PrivateBoundNames cannot have duplicates except getter+setter pairs. 1916 1916 + A static and instance private member with the same name is always an error. *) 1917 1917 + let diff_static = List.filter (fun (n, _, s) -> n = name && s <> is_static) !private_names in 1918 1918 + List.iter (fun (_, existing_kind, _) -> 1919 1919 + match existing_kind, kind with 1920 1920 + | `Getter, `Setter | `Setter, `Getter -> 1921 1921 + (* Static getter with non-static setter or vice versa is an error *) 1922 1922 + error parser Private_static_getter_setter_mismatch 1923 1923 + | _ -> 1924 1924 + (* Static and instance with same name (not getter/setter pair) is an error *) 1925 1925 + error parser (Duplicate_private_name name) 1926 1926 + ) diff_static; 1927 1927 + private_names := (name, kind, is_static) :: !private_names; 1928 1928 + (* Also add to the parser's private name scope for AllPrivateNamesValid check *) 1929 1929 + add_private_to_scope name 1930 1930 + in 836 1931 while current_token parser <> Token.RBrace && not (is_at_end parser) do 837 1932 (* Handle empty semicolons (empty class elements) *) 838 1933 if current_token parser = Token.Semicolon then begin 839 1934 advance parser; 840 1935 (* Continue to next iteration *) 841 1936 end else begin 1937 1937 + (* Parse decorators for this element *) 1938 1938 + let element_decorators = parse_decorator_list parser in 842 1939 (* Check for static keyword *) 843 1940 (* If 'static' is followed by ;, }, (, or =, treat it as field name not modifier *) 844 1941 let is_static, parsed_static_block = 845 1942 match current_token parser with 846 846 - | Token.Keyword Token.Kw_static -> 1943 1943 + | Token.Keyword Token.Kw_static 1944 1944 + | Token.Escaped_identifier "static" -> 1945 1945 + let escaped = match current_token parser with Token.Escaped_identifier _ -> true | _ -> false in 847 1946 let next = (Lexer.peek parser.lexer).tok in 848 1947 if next = Token.Semicolon || next = Token.RBrace || 849 1948 next = Token.LParen || next = Token.Eq then 850 1949 (* 'static' is the property name, not a modifier *) 851 1950 (false, false) 852 1951 else begin 1952 1952 + (* When 'static' is used as modifier, it cannot contain escapes *) 1953 1953 + if escaped then error parser (Escaped_contextual_keyword "static"); 853 1954 advance parser; (* consume 'static' *) 854 1955 (* Check for static initialization block *) 855 1956 if current_token parser = Token.LBrace then begin 856 1957 advance parser; (* consume '{' *) 1958 1958 + (* Static blocks: 'await' is reserved, 'yield' is not allowed, return not allowed, 1959 1959 + labels from outside can't be break/continue targets *) 1960 1960 + let saved_in_static_block = parser.in_static_block in 1961 1961 + let saved_in_function = parser.in_function in 1962 1962 + let saved_in_non_arrow_function = parser.in_non_arrow_function in 1963 1963 + let saved_in_generator = parser.in_generator in 1964 1964 + let saved_in_iteration = parser.in_iteration in 1965 1965 + let saved_in_switch = parser.in_switch in 1966 1966 + let saved_labels = parser.labels in 1967 1967 + let saved_iteration_labels = parser.iteration_labels in 1968 1968 + let saved_allow_super_property = parser.allow_super_property in 1969 1969 + parser.in_static_block <- true; 1970 1970 + parser.in_function <- false; (* 'return' not allowed in static block *) 1971 1971 + parser.in_non_arrow_function <- true; (* new.target IS allowed in static blocks *) 1972 1972 + parser.in_generator <- false; (* 'yield' not allowed in static block *) 1973 1973 + parser.in_iteration <- false; (* 'break'/'continue' without label not allowed *) 1974 1974 + parser.in_switch <- false; (* 'break' without label not allowed *) 1975 1975 + parser.labels <- []; (* labels from outside can't be targets *) 1976 1976 + parser.iteration_labels <- []; 1977 1977 + parser.allow_super_property <- true; (* super.x is allowed in static blocks *) 1978 1978 + (* Static blocks have function-like scope - var declarations don't leak out *) 1979 1979 + push_scope parser ~is_function:true; 857 1980 let stmts = ref [] in 858 1981 while current_token parser <> Token.RBrace && not (is_at_end parser) do 859 1982 stmts := parse_statement parser :: !stmts 860 1983 done; 1984 1984 + pop_scope parser; 1985 1985 + parser.in_static_block <- saved_in_static_block; 1986 1986 + parser.in_function <- saved_in_function; 1987 1987 + parser.in_non_arrow_function <- saved_in_non_arrow_function; 1988 1988 + parser.in_generator <- saved_in_generator; 1989 1989 + parser.in_iteration <- saved_in_iteration; 1990 1990 + parser.in_switch <- saved_in_switch; 1991 1991 + parser.labels <- saved_labels; 1992 1992 + parser.iteration_labels <- saved_iteration_labels; 1993 1993 + parser.allow_super_property <- saved_allow_super_property; 861 1994 expect parser Token.RBrace; 862 1995 elements := Ast.Static_block (List.rev !stmts) :: !elements; 863 1996 (true, true) (* is_static=true, parsed_static_block=true *) ··· 874 2007 None 875 2008 in 876 2009 expect_semicolon parser; 877 877 - elements := Ast.Property_definition { key; value; static = false; computed = false } :: !elements; 2010 2010 + elements := Ast.Property_definition { key; value; static = false; computed = false; decorators = element_decorators } :: !elements; 878 2011 (false, true) (* is_static=false, parsed_static_block=true (skip rest) *) 879 2012 end else begin 880 2013 (true, false) (* is_static=true, continue parsing element *) ··· 892 2025 end else 893 2026 false 894 2027 in 895 895 - (* Check for async *) 2028 2028 + (* Check for async - must not contain escapes *) 896 2029 let is_async = 897 897 - match current_token parser with 898 898 - | Token.Identifier "async" when not (Lexer.peek parser.lexer).preceded_by_newline -> 2030 2030 + match is_contextual_token (current_token parser) "async" with 2031 2031 + | Some escaped when not (Lexer.peek parser.lexer).preceded_by_newline -> 2032 2032 + if escaped then error parser (Escaped_contextual_keyword "async"); 899 2033 advance parser; 900 2034 true 901 2035 | _ -> false 902 2036 in 903 2037 let is_generator = is_generator || (current_token parser = Token.Star && (advance parser; true)) in 904 904 - (* Check for getter/setter - only if next token is on same line *) 2038 2038 + (* Check for accessor keyword (auto-accessor fields) - must not contain escapes. 2039 2039 + accessor is only the keyword if followed by a property name token, not =, ;, (, or newline. 2040 2040 + If followed by those, then "accessor" is itself the property name. *) 2041 2041 + let is_accessor = 2042 2042 + match is_contextual_token (current_token parser) "accessor" with 2043 2043 + | Some escaped when not (Lexer.peek parser.lexer).preceded_by_newline -> 2044 2044 + let next = Lexer.peek parser.lexer in 2045 2045 + let next_is_property_name = match next.tok with 2046 2046 + | Token.Identifier _ | Token.Escaped_identifier _ 2047 2047 + | Token.String _ | Token.Number _ | Token.BigInt _ 2048 2048 + | Token.Private_identifier _ | Token.LBracket 2049 2049 + | Token.Keyword _ -> true 2050 2050 + | _ -> false 2051 2051 + in 2052 2052 + if next_is_property_name then begin 2053 2053 + if escaped then error parser (Escaped_contextual_keyword "accessor"); 2054 2054 + advance parser; 2055 2055 + true 2056 2056 + end else false 2057 2057 + | _ -> false 2058 2058 + in 2059 2059 + (* Check for getter/setter - only if next token is on same line - must not contain escapes *) 905 2060 let kind = 906 2061 match current_token parser with 907 907 - | Token.Identifier "get" -> 2062 2062 + | (Token.Identifier "get" | Token.Escaped_identifier "get") -> 908 2063 let next = Lexer.peek parser.lexer in 909 2064 (* get is accessor prefix only if followed by name on same line *) 910 2065 if next.tok <> Token.LParen && not next.preceded_by_newline then begin 2066 2066 + (match current_token parser with 2067 2067 + | Token.Escaped_identifier _ -> error parser (Escaped_contextual_keyword "get") 2068 2068 + | _ -> ()); 911 2069 advance parser; 912 2070 Ast.Get_method 913 2071 end else Ast.Method 914 914 - | Token.Identifier "set" -> 2072 2072 + | (Token.Identifier "set" | Token.Escaped_identifier "set") -> 915 2073 let next = Lexer.peek parser.lexer in 916 2074 (* set is accessor prefix only if followed by name on same line *) 917 2075 if next.tok <> Token.LParen && not next.preceded_by_newline then begin 2076 2076 + (match current_token parser with 2077 2077 + | Token.Escaped_identifier _ -> error parser (Escaped_contextual_keyword "set") 2078 2078 + | _ -> ()); 918 2079 advance parser; 919 2080 Ast.Set_method 920 2081 end else Ast.Method ··· 934 2095 k 935 2096 end else begin 936 2097 match current_token parser with 937 937 - | Token.Identifier name -> 2098 2098 + | Token.Identifier name | Token.Escaped_identifier name -> 938 2099 let loc = current_loc parser in 939 2100 advance parser; 940 2101 Ast.mk_expr ~loc (Ast.Literal (Ast.Lit_string name)) ··· 956 2117 advance parser; 957 2118 Ast.mk_expr ~loc (Ast.Literal (Ast.Lit_string s)) 958 2119 | Token.Private_identifier name -> 2120 2120 + (* Private element cannot be named #constructor *) 2121 2121 + if name = "constructor" then error parser Private_constructor; 959 2122 let loc = current_loc parser in 960 2123 advance parser; 961 2124 Ast.mk_expr ~loc (Ast.Private_identifier name) 962 2125 | _ -> error parser Expected_identifier 963 2126 end 964 2127 in 2128 2128 + (* Check for static prototype (both methods and fields are forbidden) *) 2129 2129 + let is_static_prototype = is_static && not computed && 2130 2130 + (match key.Ast.expr with 2131 2131 + | Ast.Literal (Ast.Lit_string "prototype") -> true 2132 2132 + | _ -> false) 2133 2133 + in 965 2134 (* Check for constructor *) 2135 2135 + let is_constructor_method = not computed && not is_static && 2136 2136 + (match key.Ast.expr with 2137 2137 + | Ast.Literal (Ast.Lit_string "constructor") -> true 2138 2138 + | _ -> false) 2139 2139 + in 2140 2140 + (* Check that constructor is not a special method (getter, setter, generator, async) *) 966 2141 let kind = 967 967 - if not computed && not is_static then 968 968 - match key.Ast.expr with 969 969 - | Ast.Literal (Ast.Lit_string "constructor") -> Ast.Constructor 970 970 - | _ -> kind 971 971 - else kind 2142 2142 + if is_constructor_method then begin 2143 2143 + (* Check for duplicate constructor *) 2144 2144 + if !has_constructor then 2145 2145 + error parser Duplicate_constructor; 2146 2146 + has_constructor := true; 2147 2147 + if is_generator || is_async || kind <> Ast.Method then 2148 2148 + error parser Special_constructor; 2149 2149 + Ast.Constructor 2150 2150 + end else 2151 2151 + kind 2152 2152 + in 2153 2153 + (* Check for field named "constructor" (non-computed) - not allowed *) 2154 2154 + let is_constructor_field = not computed && 2155 2155 + (match key.Ast.expr with 2156 2156 + | Ast.Literal (Ast.Lit_string "constructor") -> true 2157 2157 + | _ -> false) in 2158 2158 + (* Helper to check and register private name *) 2159 2159 + let register_private name element_kind = 2160 2160 + let pk = match element_kind with 2161 2161 + | `Field -> `Field 2162 2162 + | `Method -> `Method 2163 2163 + | `Getter -> `Getter 2164 2164 + | `Setter -> `Setter 2165 2165 + in 2166 2166 + check_private_name name pk is_static 972 2167 in 973 2168 (* Parse method body or property *) 974 2169 match current_token parser with 975 2170 | Token.LParen -> 976 976 - let fn = parse_function_body parser ~is_generator ~is_async in 977 977 - elements := Ast.Method_definition { key; value = fn; kind; static = is_static; computed } :: !elements 2171 2171 + (* Static prototype method is not allowed *) 2172 2172 + if is_static_prototype then error parser Static_prototype_method; 2173 2173 + let fn = parse_function_body parser ~is_generator ~is_async ~in_class:true ~method_kind:kind () in 2174 2174 + (* Check for duplicate private names *) 2175 2175 + (match key.Ast.expr with 2176 2176 + | Ast.Private_identifier name -> 2177 2177 + let pk = match kind with 2178 2178 + | Ast.Get_method -> `Getter 2179 2179 + | Ast.Set_method -> `Setter 2180 2180 + | _ -> `Method 2181 2181 + in 2182 2182 + register_private name pk 2183 2183 + | _ -> ()); 2184 2184 + elements := Ast.Method_definition { key; value = fn; kind; static = is_static; computed; decorators = element_decorators } :: !elements 978 2185 | Token.Eq -> 2186 2186 + if is_constructor_field then error parser Constructor_field; 2187 2187 + (* Static prototype field is not allowed *) 2188 2188 + if is_static_prototype then error parser Static_prototype_method; 2189 2189 + (* Check for duplicate private field names *) 2190 2190 + (match key.Ast.expr with 2191 2191 + | Ast.Private_identifier name -> register_private name `Field 2192 2192 + | _ -> ()); 979 2193 advance parser; 2194 2194 + let saved_in_class_field_init = parser.in_class_field_init in 2195 2195 + let saved_super_call_forbidden = parser.super_call_forbidden in 2196 2196 + let saved_allow_super_property = parser.allow_super_property in 2197 2197 + let saved_in_async = parser.in_async in 2198 2198 + let saved_in_generator = parser.in_generator in 2199 2199 + parser.in_class_field_init <- true; 2200 2200 + parser.super_call_forbidden <- true; (* super() is never allowed in field initializers *) 2201 2201 + parser.allow_super_property <- true; (* super.x IS allowed in field initializers *) 2202 2202 + (* Class field initializers are NOT in the async/generator context of the enclosing function. 2203 2203 + await/yield are identifiers in field initializers (except when the class is inside a module 2204 2204 + for await or inside a generator for yield). *) 2205 2205 + parser.in_async <- false; (* await is an identifier in field initializers *) 2206 2206 + parser.in_generator <- false; (* yield is an identifier in field initializers *) 980 2207 let value = Some (parse_assignment_expression parser) in 2208 2208 + parser.in_class_field_init <- saved_in_class_field_init; 2209 2209 + parser.super_call_forbidden <- saved_super_call_forbidden; 2210 2210 + parser.allow_super_property <- saved_allow_super_property; 2211 2211 + parser.in_async <- saved_in_async; 2212 2212 + parser.in_generator <- saved_in_generator; 981 2213 expect_semicolon parser; 982 982 - elements := Ast.Property_definition { key; value; static = is_static; computed } :: !elements 2214 2214 + let element = if is_accessor 2215 2215 + then Ast.Accessor_definition { key; value; static = is_static; computed; decorators = element_decorators } 2216 2216 + else Ast.Property_definition { key; value; static = is_static; computed; decorators = element_decorators } 2217 2217 + in 2218 2218 + elements := element :: !elements 983 2219 | Token.Semicolon -> 2220 2220 + if is_constructor_field then error parser Constructor_field; 2221 2221 + (* Static prototype field is not allowed *) 2222 2222 + if is_static_prototype then error parser Static_prototype_method; 2223 2223 + (* Check for duplicate private field names *) 2224 2224 + (match key.Ast.expr with 2225 2225 + | Ast.Private_identifier name -> register_private name `Field 2226 2226 + | _ -> ()); 984 2227 advance parser; 985 985 - elements := Ast.Property_definition { key; value = None; static = is_static; computed } :: !elements 2228 2228 + let element = if is_accessor 2229 2229 + then Ast.Accessor_definition { key; value = None; static = is_static; computed; decorators = element_decorators } 2230 2230 + else Ast.Property_definition { key; value = None; static = is_static; computed; decorators = element_decorators } 2231 2231 + in 2232 2232 + elements := element :: !elements 986 2233 | _ -> 987 987 - (* Property without value *) 988 988 - elements := Ast.Property_definition { key; value = None; static = is_static; computed } :: !elements 2234 2234 + if is_constructor_field then error parser Constructor_field; 2235 2235 + (* Static prototype field is not allowed *) 2236 2236 + if is_static_prototype then error parser Static_prototype_method; 2237 2237 + (* Check for duplicate private field names *) 2238 2238 + (match key.Ast.expr with 2239 2239 + | Ast.Private_identifier name -> register_private name `Field 2240 2240 + | _ -> ()); 2241 2241 + (* Property without value - ASI applies, but requires newline before next element *) 2242 2242 + (* If the next token is on the same line, it's an error *) 2243 2243 + if current_token parser <> Token.RBrace && not parser.current.preceded_by_newline then 2244 2244 + error parser (Expected_token (";", current_token parser)); 2245 2245 + let element = if is_accessor 2246 2246 + then Ast.Accessor_definition { key; value = None; static = is_static; computed; decorators = element_decorators } 2247 2247 + else Ast.Property_definition { key; value = None; static = is_static; computed; decorators = element_decorators } 2248 2248 + in 2249 2249 + elements := element :: !elements 989 2250 end (* if not parsed_static_block *) 990 2251 end (* else (not semicolon) *) 991 2252 done; 992 2253 let end_loc = current_loc parser in 993 2254 expect parser Token.RBrace; 2255 2255 + (* Validate all pending private name references before popping scope *) 2256 2256 + validate_pending_private_names parser; 2257 2257 + (* Pop the private name scope for this class *) 2258 2258 + (match parser.private_name_scopes with 2259 2259 + | _ :: rest -> parser.private_name_scopes <- rest 2260 2260 + | [] -> ()); 994 2261 (* After class body, regex is allowed (not division) *) 995 2262 reset_regexp_context parser; 996 2263 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in ··· 1025 2292 advance parser; 1026 2293 let property_loc = current_loc parser in 1027 2294 let property = match current_token parser with 1028 1028 - | Token.Identifier name -> 2295 2295 + | Token.Identifier name | Token.Escaped_identifier name -> 1029 2296 advance parser; 1030 2297 Ast.mk_expr ~loc:property_loc (Ast.Literal (Ast.Lit_string name)) 1031 2298 | Token.Keyword kw -> ··· 1033 2300 advance parser; 1034 2301 Ast.mk_expr ~loc:property_loc (Ast.Literal (Ast.Lit_string name)) 1035 2302 | Token.Private_identifier name -> 2303 2303 + (* super.#x is not allowed - private names cannot be accessed on super *) 2304 2304 + (match expr.Ast.expr with 2305 2305 + | Ast.Super -> error parser Super_private_access 2306 2306 + | _ -> ()); 1036 2307 advance parser; 2308 2308 + (* Record this private name reference for later validation *) 2309 2309 + record_private_name_ref parser name property_loc; 1037 2310 Ast.mk_expr ~loc:property_loc (Ast.Private_identifier name) 1038 2311 | _ -> error parser Expected_identifier 1039 2312 in ··· 1076 2349 | Token.Private_identifier name -> 1077 2350 let property_loc = current_loc parser in 1078 2351 advance parser; 2352 2352 + (* Record this private name reference for later validation *) 2353 2353 + record_private_name_ref parser name property_loc; 1079 2354 let property = Ast.mk_expr ~loc:property_loc (Ast.Private_identifier name) in 1080 2355 let loc = Source.mk_loc ~start:expr.Ast.loc.start ~end_:property_loc.end_ () in 1081 2356 let new_expr = Ast.mk_expr ~loc (Ast.Member { object_ = expr; property; computed = false; optional = true }) in 1082 2357 parse_member_expression_tail parser new_expr 1083 1083 - | Token.Identifier name -> 2358 2358 + | Token.Identifier name | Token.Escaped_identifier name -> 1084 2359 let property_loc = current_loc parser in 1085 2360 advance parser; 1086 2361 let property = Ast.mk_expr ~loc:property_loc (Ast.Literal (Ast.Lit_string name)) in ··· 1106 2381 and parse_call_expression_tail parser (expr : Ast.expression) : Ast.expression = 1107 2382 match current_token parser with 1108 2383 | Token.LParen -> 2384 2384 + (* Check for super() - only allowed in constructor of derived class *) 2385 2385 + (match expr.Ast.expr with 2386 2386 + | Ast.Super when parser.super_call_forbidden || not parser.in_derived_class -> 2387 2387 + error parser Super_call_outside_constructor 2388 2388 + | _ -> ()); 1109 2389 let arguments = parse_arguments parser in 1110 2390 let end_loc = current_loc parser in 1111 2391 let loc = Source.mk_loc ~start:expr.Ast.loc.start ~end_:end_loc.end_ () in ··· 1116 2396 let new_expr = parse_member_expression_tail parser expr in 1117 2397 parse_call_expression_tail parser new_expr 1118 2398 1119 1119 - (* Tagged template: tag`template` *) 1120 1120 - | Token.Template (Token.Template_no_sub raw) -> 2399 2399 + (* Tagged template: tag`template` - invalid escapes allowed *) 2400 2400 + | Token.Template (Token.Template_no_sub { raw; cooked }) -> 2401 2401 + (* Check for optional chaining - template literals not allowed after ?. *) 2402 2402 + let rec has_optional_chain (e : Ast.expression) = 2403 2403 + match e.Ast.expr with 2404 2404 + | Ast.Member { optional = true; _ } -> true 2405 2405 + | Ast.Call { optional = true; _ } -> true 2406 2406 + | Ast.Member { object_; optional = false; _ } -> has_optional_chain object_ 2407 2407 + | Ast.Call { callee; optional = false; _ } -> has_optional_chain callee 2408 2408 + | _ -> false 2409 2409 + in 2410 2410 + if has_optional_chain expr then 2411 2411 + error parser (Expected_token ("}", current_token parser)); (* Using existing error *) 1121 2412 advance parser; 1122 2413 let quasi = { 1123 1123 - Ast.quasis = [{ Ast.raw; cooked = Some raw; tail = true }]; 2414 2414 + Ast.quasis = [{ Ast.raw; cooked; tail = true }]; 1124 2415 expressions = []; 1125 2416 } in 1126 2417 let end_loc = current_loc parser in ··· 1128 2419 let new_expr = Ast.mk_expr ~loc (Ast.TaggedTemplate { tag = expr; quasi }) in 1129 2420 parse_call_expression_tail parser new_expr 1130 2421 1131 1131 - | Token.Template (Token.Template_head raw) -> 2422 2422 + | Token.Template (Token.Template_head { raw; cooked }) -> 2423 2423 + (* Check for optional chaining - template literals not allowed after ?. *) 2424 2424 + let rec has_optional_chain (e : Ast.expression) = 2425 2425 + match e.Ast.expr with 2426 2426 + | Ast.Member { optional = true; _ } -> true 2427 2427 + | Ast.Call { optional = true; _ } -> true 2428 2428 + | Ast.Member { object_; optional = false; _ } -> has_optional_chain object_ 2429 2429 + | Ast.Call { callee; optional = false; _ } -> has_optional_chain callee 2430 2430 + | _ -> false 2431 2431 + in 2432 2432 + if has_optional_chain expr then 2433 2433 + error parser (Expected_token ("}", current_token parser)); 1132 2434 let start_loc = expr.Ast.loc in 1133 2435 advance parser; 1134 1134 - let quasis = ref [{ Ast.raw; cooked = Some raw; tail = false }] in 2436 2436 + let quasis = ref [{ Ast.raw; cooked; tail = false }] in 1135 2437 let expressions = ref [] in 1136 2438 let rec parse_template_rest () = 1137 2439 let expr = parse_expression parser in ··· 1139 2441 let tail_tok = Lexer.scan_template_tail parser.lexer in 1140 2442 parser.current <- tail_tok; 1141 2443 match tail_tok.tok with 1142 1142 - | Token.Template (Token.Template_tail raw) -> 1143 1143 - quasis := { Ast.raw; cooked = Some raw; tail = true } :: !quasis; 2444 2444 + | Token.Template (Token.Template_tail { raw; cooked }) -> 2445 2445 + quasis := { Ast.raw; cooked; tail = true } :: !quasis; 1144 2446 advance parser 1145 1145 - | Token.Template (Token.Template_middle raw) -> 1146 1146 - quasis := { Ast.raw; cooked = Some raw; tail = false } :: !quasis; 2447 2447 + | Token.Template (Token.Template_middle { raw; cooked }) -> 2448 2448 + quasis := { Ast.raw; cooked; tail = false } :: !quasis; 1147 2449 advance parser; 1148 2450 parse_template_rest () 1149 2451 | _ -> error parser (Expected_token ("}", current_token parser)) ··· 1161 2463 | _ -> expr 1162 2464 1163 2465 (* Check if expression is valid for update operations (++/--) *) 1164 1164 - and is_simple_assignment_target (expr : Ast.expression) : bool = 2466 2466 + and is_simple_assignment_target ?(allow_call=false) (expr : Ast.expression) : bool = 1165 2467 match expr.Ast.expr with 1166 1166 - | Ast.Identifier _ | Ast.Member _ -> true 1167 1167 - | Ast.Paren inner -> is_simple_assignment_target inner 2468 2468 + | Ast.Identifier _ -> true 2469 2469 + | Ast.Member { optional = true; _ } -> false (* Optional chaining not allowed *) 2470 2470 + | Ast.Member _ -> true 2471 2471 + | Ast.Call _ when allow_call -> true (* Annex B: call expressions allowed in non-strict mode *) 2472 2472 + | Ast.Paren inner -> is_simple_assignment_target ~allow_call inner 1168 2473 | _ -> false 1169 2474 1170 1170 - and validate_update_target _parser (argument : Ast.expression) : unit = 1171 1171 - if not (is_simple_assignment_target argument) then 1172 1172 - raise (Parse_error (Invalid_assignment_target, argument.Ast.loc)) 2475 2475 + and validate_update_target parser (argument : Ast.expression) : unit = 2476 2476 + if not (is_simple_assignment_target ~allow_call:(not parser.strict_mode) argument) then 2477 2477 + raise (Parse_error (Invalid_assignment_target, argument.Ast.loc)); 2478 2478 + (* In strict mode, cannot update eval or arguments *) 2479 2479 + if parser.strict_mode then 2480 2480 + match argument.Ast.expr with 2481 2481 + | Ast.Identifier { name; _ } when name = "eval" || name = "arguments" -> 2482 2482 + error parser (Strict_eval_arguments name) 2483 2483 + | _ -> () 1173 2484 1174 2485 and parse_update_expression parser : Ast.expression = 1175 2486 let start_loc = current_loc parser in ··· 1242 2553 | Token.Keyword Token.Kw_delete -> 1243 2554 advance parser; 1244 2555 let argument = parse_unary_expression parser in 2556 2556 + (* Check for delete on private name access or identifier in strict mode *) 2557 2557 + let rec check_delete_strict e = 2558 2558 + match e.Ast.expr with 2559 2559 + | Ast.Identifier _ -> 2560 2560 + (* In strict mode, delete of unqualified identifier is an error *) 2561 2561 + error parser Invalid_assignment_target 2562 2562 + | Ast.Member { property; _ } -> 2563 2563 + (match property.Ast.expr with 2564 2564 + | Ast.Private_identifier _ -> 2565 2565 + error parser Invalid_assignment_target (* delete of private name *) 2566 2566 + | _ -> ()) 2567 2567 + | Ast.Call { callee; _ } -> 2568 2568 + check_delete_strict callee (* check x().#m - callee is x() *) 2569 2569 + | Ast.Paren inner -> check_delete_strict inner 2570 2570 + | _ -> () 2571 2571 + in 2572 2572 + if parser.strict_mode then check_delete_strict argument; 1245 2573 let loc = Source.mk_loc ~start:start_loc.start ~end_:argument.Ast.loc.end_ () in 1246 2574 Ast.mk_expr ~loc (Ast.Unary { operator = Ast.Delete; argument }) 1247 1247 - | Token.Keyword Token.Kw_await when parser.in_async || (parser.in_module && not parser.in_function) -> 2575 2575 + | Token.Keyword Token.Kw_await when (parser.in_async || (parser.in_module && not parser.in_function)) && not parser.in_static_block -> 1248 2576 (* await is allowed in async functions and at module top level (top-level await in modules) *) 1249 2577 (* In scripts at top level, 'await' is an identifier, not an await expression *) 2578 2578 + (* AwaitExpression is not allowed in formal parameters or in static blocks *) 2579 2579 + if parser.in_formal_parameters then 2580 2580 + error parser Await_in_parameter; 1250 2581 advance parser; 1251 2582 let argument = parse_unary_expression parser in 1252 2583 let loc = Source.mk_loc ~start:start_loc.start ~end_:argument.Ast.loc.end_ () in ··· 1308 2639 let left = parse_unary_expression parser in 1309 2640 parse_binary_expression_tail parser left min_prec 1310 2641 2642 2642 + (* Helper to check if expression contains ?? or ||/&& at top level (not parenthesized) *) 2643 2643 + and has_nullish_at_top (e : Ast.expression) = 2644 2644 + match e.Ast.expr with 2645 2645 + | Ast.Logical { operator = Ast.Nullish; _ } -> true 2646 2646 + | Ast.Logical { operator = (Ast.Or | Ast.And); left; right } -> 2647 2647 + has_nullish_at_top left || has_nullish_at_top right 2648 2648 + | _ -> false 2649 2649 + 2650 2650 + and has_logical_at_top (e : Ast.expression) = 2651 2651 + match e.Ast.expr with 2652 2652 + | Ast.Logical { operator = (Ast.Or | Ast.And); _ } -> true 2653 2653 + | Ast.Logical { operator = Ast.Nullish; left; right } -> 2654 2654 + has_logical_at_top left || has_logical_at_top right 2655 2655 + | _ -> false 2656 2656 + 1311 2657 and parse_binary_expression_tail parser (left : Ast.expression) min_prec : Ast.expression = 1312 2658 let tok = current_token parser in 1313 2659 (* Check if 'in' is allowed in this context *) ··· 1320 2666 if prec < min_prec then 1321 2667 left 1322 2668 else begin 2669 2669 + (* Check for unary expression before exponentiation operator - this is ambiguous and forbidden *) 2670 2670 + if tok = Token.Star_star then begin 2671 2671 + let is_unary = match left.Ast.expr with 2672 2672 + | Ast.Unary _ -> true (* -x, +x, ~x, !x, typeof x, void x, delete x *) 2673 2673 + | Ast.Await _ -> true (* await x ** y is ambiguous *) 2674 2674 + | _ -> false 2675 2675 + in 2676 2676 + if is_unary then 2677 2677 + raise (Parse_error (Invalid_assignment_target, left.Ast.loc)) (* Using this error for now *) 2678 2678 + end; 2679 2679 + (* Check for nullish (??) mixed with logical (|| &&) *) 2680 2680 + if tok = Token.Question_question && has_logical_at_top left then 2681 2681 + error parser Nullish_mixing_logical; 2682 2682 + if (tok = Token.Pipe_pipe || tok = Token.Ampersand_ampersand) && has_nullish_at_top left then 2683 2683 + error parser Nullish_mixing_logical; 1323 2684 advance parser; 1324 1324 - let next_min_prec = if tok = Token.Star_star then prec else prec + 1 in 2685 2685 + (* For PrivateIdentifier in ShiftExpression, the RHS is ShiftExpression, not RelationalExpression. 2686 2686 + This means another 'in' or 'instanceof' is not allowed in the RHS. 2687 2687 + Shift operators have precedence 8, relational have 7. *) 2688 2688 + let is_private_in = tok = Token.Keyword Token.Kw_in && (match left.Ast.expr with Ast.Private_identifier _ -> true | _ -> false) in 2689 2689 + let next_min_prec = 2690 2690 + if tok = Token.Star_star then prec 2691 2691 + else if is_private_in then 8 (* Parse at ShiftExpression level *) 2692 2692 + else prec + 1 2693 2693 + in 1325 2694 let right = parse_binary_expression parser next_min_prec in 2695 2695 + (* For PrivateIdentifier in ShiftExpression, the RHS cannot be a bare PrivateIdentifier. 2696 2696 + A bare PrivateIdentifier is only valid immediately before 'in', not as a general expression. *) 2697 2697 + if is_private_in then 2698 2698 + (match right.Ast.expr with 2699 2699 + | Ast.Private_identifier _ -> 2700 2700 + raise (Parse_error (Unexpected_token (Token.Private_identifier ""), right.Ast.loc)) 2701 2701 + | _ -> ()); 2702 2702 + (* Also check that right side doesn't mix nullish with logical *) 2703 2703 + if tok = Token.Question_question && has_logical_at_top right then 2704 2704 + error parser Nullish_mixing_logical; 2705 2705 + if (tok = Token.Pipe_pipe || tok = Token.Ampersand_ampersand) && has_nullish_at_top right then 2706 2706 + error parser Nullish_mixing_logical; 1326 2707 let loc = Source.mk_loc ~start:left.Ast.loc.start ~end_:right.Ast.loc.end_ () in 1327 2708 let new_left = 1328 2709 match token_to_logical_op tok with ··· 1355 2736 end else 1356 2737 test 1357 2738 1358 1358 - and expr_to_pattern (expr : Ast.expression) : Ast.pattern = 2739 2739 + (* ~allow_call: when true, allow call expressions as assignment targets (Annex B web compat) *) 2740 2740 + and expr_to_pattern ?(allow_call=false) (expr : Ast.expression) : Ast.pattern = 1359 2741 let pat_desc = match expr.Ast.expr with 1360 2742 | Ast.Identifier id -> Ast.Pat_identifier id 1361 2743 | Ast.Array elements -> 2744 2744 + let has_rest = ref false in 1362 2745 let pats = List.map (function 1363 1363 - | None -> None 2746 2746 + | None -> 2747 2747 + (* Elision after rest element is an error *) 2748 2748 + if !has_rest then raise (Parse_error (Invalid_destructuring, expr.Ast.loc)); 2749 2749 + None 1364 2750 | Some e -> 1365 2751 match e.Ast.expr with 1366 1366 - | Ast.Spread arg -> Some (Ast.Array_pat_rest (expr_to_pattern arg)) 1367 1367 - | _ -> Some (Ast.Array_pat_element (expr_to_pattern e)) 2752 2752 + | Ast.Spread arg -> 2753 2753 + (* Multiple rest elements are not allowed *) 2754 2754 + if !has_rest then raise (Parse_error (Invalid_destructuring, e.Ast.loc)); 2755 2755 + (* Rest element cannot have initializer *) 2756 2756 + (match arg.Ast.expr with 2757 2757 + | Ast.Assignment _ -> raise (Parse_error (Invalid_destructuring, e.Ast.loc)) 2758 2758 + | _ -> ()); 2759 2759 + has_rest := true; 2760 2760 + Some (Ast.Array_pat_rest (expr_to_pattern ~allow_call arg)) 2761 2761 + | _ -> 2762 2762 + (* Element after rest element is an error *) 2763 2763 + if !has_rest then raise (Parse_error (Invalid_destructuring, e.Ast.loc)); 2764 2764 + Some (Ast.Array_pat_element (expr_to_pattern ~allow_call e)) 1368 2765 ) elements in 1369 2766 Ast.Pat_array pats 1370 2767 | Ast.Object props -> 2768 2768 + let has_rest = ref false in 1371 2769 let pat_props = List.map (function 1372 2770 | Ast.Spread_element e -> 1373 1373 - Ast.Object_pat_rest (expr_to_pattern e) 2771 2771 + (* Rest element must be the last property - check if we already saw one *) 2772 2772 + if !has_rest then raise (Parse_error (Invalid_destructuring, e.Ast.loc)); 2773 2773 + has_rest := true; 2774 2774 + Ast.Object_pat_rest (expr_to_pattern ~allow_call e) 1374 2775 | Ast.Property { key; value; shorthand; computed; _ } -> 2776 2776 + (* Property after rest element is an error *) 2777 2777 + if !has_rest then raise (Parse_error (Invalid_destructuring, value.Ast.loc)); 1375 2778 Ast.Object_pat_property { 1376 2779 key; 1377 1377 - value = expr_to_pattern value; 2780 2780 + value = expr_to_pattern ~allow_call value; 1378 2781 shorthand; 1379 2782 computed; 1380 2783 } ··· 1382 2785 Ast.Pat_object pat_props 1383 2786 | Ast.Assignment { left; right; operator = Ast.Assign } -> 1384 2787 Ast.Pat_assignment { left; right } 2788 2788 + | Ast.Member { optional = true; _ } -> 2789 2789 + (* Optional chaining expressions (x?.y) cannot be assignment targets *) 2790 2790 + raise (Parse_error (Invalid_assignment_target, expr.Ast.loc)) 1385 2791 | Ast.Member _ -> 1386 2792 Ast.Pat_expression expr 2793 2793 + | Ast.Call _ when allow_call -> 2794 2794 + (* Annex B: call expressions as assignment targets are allowed in non-strict mode, 2795 2795 + the error is deferred to runtime (ReferenceError) *) 2796 2796 + Ast.Pat_expression expr 1387 2797 | Ast.Paren inner -> 1388 1388 - (* Parenthesized expression is valid assignment target only if inner is valid *) 2798 2798 + (* Parenthesized expression is valid assignment target only if inner is identifier or member. 2799 2799 + Parenthesized array/object literals are NOT valid destructuring patterns - 2800 2800 + only bare array/object at expression level can be destructuring. 2801 2801 + E.g., [a] = x is valid, ([a]) = x is not. *) 1389 2802 (match inner.Ast.expr with 1390 1390 - | Ast.Identifier _ | Ast.Member _ -> Ast.Pat_expression expr 2803 2803 + | Ast.Identifier _ -> Ast.Pat_expression expr 2804 2804 + | Ast.Member { optional = true; _ } -> 2805 2805 + raise (Parse_error (Invalid_assignment_target, expr.Ast.loc)) 2806 2806 + | Ast.Member _ -> Ast.Pat_expression expr 2807 2807 + | Ast.Call _ when allow_call -> Ast.Pat_expression expr 1391 2808 | Ast.Paren _ -> 1392 1392 - (* Recursively check nested parens *) 1393 1393 - let _ = expr_to_pattern inner in 1394 1394 - Ast.Pat_expression expr 1395 1395 - | Ast.Array _ | Ast.Object _ -> 1396 1396 - (* Destructuring patterns in parens are valid *) 1397 1397 - ignore (expr_to_pattern inner); 2809 2809 + (* Recursively check nested parens - only identifiers/members allowed *) 2810 2810 + let _ = expr_to_pattern ~allow_call inner in 1398 2811 Ast.Pat_expression expr 1399 2812 | _ -> 1400 2813 raise (Parse_error (Invalid_assignment_target, expr.Ast.loc))) ··· 1403 2816 in 1404 2817 Ast.mk_pat ~loc:expr.Ast.loc pat_desc 1405 2818 1406 1406 - and parse_arrow_function_body parser ~is_async : Ast.arrow_function = 2819 2819 + (* Validate that assignment pattern doesn't contain eval/arguments as targets in strict mode *) 2820 2820 + and validate_assignment_pattern_strict parser (pat : Ast.pattern) : unit = 2821 2821 + if parser.strict_mode then 2822 2822 + let rec check_pattern p = 2823 2823 + match p.Ast.pat with 2824 2824 + | Ast.Pat_identifier { name; _ } when name = "eval" || name = "arguments" -> 2825 2825 + error parser (Strict_eval_arguments name) 2826 2826 + | Ast.Pat_identifier _ -> () 2827 2827 + | Ast.Pat_array elements -> 2828 2828 + List.iter (function 2829 2829 + | None -> () 2830 2830 + | Some (Ast.Array_pat_element p) -> check_pattern p 2831 2831 + | Some (Ast.Array_pat_rest p) -> check_pattern p 2832 2832 + ) elements 2833 2833 + | Ast.Pat_object props -> 2834 2834 + List.iter (function 2835 2835 + | Ast.Object_pat_property { value; _ } -> check_pattern value 2836 2836 + | Ast.Object_pat_rest p -> check_pattern p 2837 2837 + ) props 2838 2838 + | Ast.Pat_assignment { left; _ } -> check_pattern left 2839 2839 + | Ast.Pat_rest p -> check_pattern p 2840 2840 + | Ast.Pat_expression e -> 2841 2841 + (* For member expressions or other expressions, check the base identifier *) 2842 2842 + let rec check_expr_target expr = 2843 2843 + match expr.Ast.expr with 2844 2844 + | Ast.Identifier { name; _ } when name = "eval" || name = "arguments" -> 2845 2845 + error parser (Strict_eval_arguments name) 2846 2846 + | Ast.Paren inner -> check_expr_target inner 2847 2847 + | _ -> () 2848 2848 + in 2849 2849 + check_expr_target e 2850 2850 + in 2851 2851 + check_pattern pat 2852 2852 + 2853 2853 + and parse_arrow_function_body parser ~is_async ?(params=[]) () : Ast.arrow_function = 1407 2854 expect parser Token.Arrow; 1408 1408 - let params = [] in (* Will be filled by caller *) 1409 2855 if current_token parser = Token.LBrace then begin 1410 2856 expect parser Token.LBrace; 2857 2857 + (* Push function scope for redeclaration detection *) 2858 2858 + push_scope parser ~is_function:true; 2859 2859 + (* Register params in scope so lexical bindings with same name will error *) 2860 2860 + let scope = current_scope parser in 2861 2861 + List.iter (fun pat -> 2862 2862 + List.iter (fun (name, loc) -> 2863 2863 + Hashtbl.replace scope.scope_bindings name { bind_name = name; bind_kind = Bind_param; bind_loc = loc } 2864 2864 + ) (collect_bound_names_from_pattern pat) 2865 2865 + ) params; 1411 2866 let saved_in_function = parser.in_function in 1412 2867 let saved_in_async = parser.in_async in 1413 2868 let saved_strict_mode = parser.strict_mode in 2869 2869 + let saved_in_static_block = parser.in_static_block in 1414 2870 parser.in_function <- true; 1415 2871 parser.in_async <- is_async; 2872 2872 + parser.in_static_block <- false; (* await is not reserved inside arrow function bodies *) 2873 2873 + (* Note: in_class_field_init is NOT reset for arrow functions - they inherit the restriction 2874 2874 + since arrow functions don't have their own 'arguments' binding *) 1416 2875 let start_loc = current_loc parser in 1417 2876 let stmts = ref [] in 1418 2877 let directives = ref [] in 1419 2878 let parsing_directives = ref true in 1420 1420 - while current_token parser <> Token.RBrace && not (is_at_end parser) do 1421 1421 - let s = parse_statement parser in 1422 1422 - if !parsing_directives then begin 1423 1423 - match s.Ast.stmt with 1424 1424 - | Ast.Expression { Ast.expr = Ast.Literal (Ast.Lit_string str); _ } -> 1425 1425 - directives := str :: !directives; 1426 1426 - if str = "use strict" then parser.strict_mode <- true 1427 1427 - | _ -> parsing_directives := false 1428 1428 - end; 1429 1429 - stmts := s :: !stmts 1430 1430 - done; 2879 2879 + (try 2880 2880 + while current_token parser <> Token.RBrace && not (is_at_end parser) do 2881 2881 + let s = parse_statement parser in 2882 2882 + if !parsing_directives then begin 2883 2883 + match s.Ast.stmt with 2884 2884 + | Ast.Expression { Ast.expr = Ast.Literal (Ast.Lit_string str); _ } -> 2885 2885 + directives := str :: !directives; 2886 2886 + if str = "use strict" then parser.strict_mode <- true 2887 2887 + | _ -> parsing_directives := false 2888 2888 + end; 2889 2889 + stmts := s :: !stmts 2890 2890 + done 2891 2891 + with e -> 2892 2892 + pop_scope parser; 2893 2893 + raise e); 2894 2894 + pop_scope parser; 1431 2895 let end_loc = current_loc parser in 1432 2896 expect parser Token.RBrace; 1433 2897 parser.in_function <- saved_in_function; 1434 2898 parser.in_async <- saved_in_async; 1435 2899 parser.strict_mode <- saved_strict_mode; 2900 2900 + parser.in_static_block <- saved_in_static_block; 1436 2901 let body_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 1437 2902 { 1438 2903 Ast.ar_params = params; ··· 1447 2912 let saved_in_function = parser.in_function in 1448 2913 let saved_in_async = parser.in_async in 1449 2914 let saved_strict_mode = parser.strict_mode in 2915 2915 + let saved_in_static_block = parser.in_static_block in 1450 2916 parser.in_function <- true; 1451 2917 parser.in_async <- is_async; 2918 2918 + parser.in_static_block <- false; (* await is not reserved inside arrow function bodies *) 2919 2919 + (* Note: in_class_field_init is NOT reset for arrow functions - they inherit the restriction 2920 2920 + since arrow functions don't have their own 'arguments' binding *) 1452 2921 let body = parse_assignment_expression parser in 1453 2922 parser.in_function <- saved_in_function; 1454 2923 parser.in_async <- saved_in_async; 1455 2924 parser.strict_mode <- saved_strict_mode; 2925 2925 + parser.in_static_block <- saved_in_static_block; 1456 2926 { 1457 2927 Ast.ar_params = params; 1458 2928 ar_body = Ast.Arrow_expression body; ··· 1460 2930 } 1461 2931 end 1462 2932 2933 2933 + (** Skip balanced parens and return the token that follows the closing paren. 2934 2934 + Returns None if we hit EOF or cannot balance parens. *) 2935 2935 + and skip_balanced_parens parser : Token.t option = 2936 2936 + let saved_pos = Lexer.save parser.lexer in 2937 2937 + let saved_current = parser.current in 2938 2938 + let rec skip depth = 2939 2939 + match current_token parser with 2940 2940 + | Token.Eof -> None 2941 2941 + | Token.LParen | Token.LBracket | Token.LBrace -> 2942 2942 + advance parser; 2943 2943 + skip (depth + 1) 2944 2944 + | Token.RParen -> 2945 2945 + if depth = 1 then begin 2946 2946 + advance parser; (* consume the ) *) 2947 2947 + let tok = current_token parser in (* token after ) *) 2948 2948 + Lexer.restore parser.lexer saved_pos; 2949 2949 + parser.current <- saved_current; 2950 2950 + Some tok 2951 2951 + end else begin 2952 2952 + advance parser; 2953 2953 + skip (depth - 1) 2954 2954 + end 2955 2955 + | Token.RBracket | Token.RBrace -> 2956 2956 + advance parser; 2957 2957 + skip (depth - 1) 2958 2958 + | _ -> 2959 2959 + advance parser; 2960 2960 + skip depth 2961 2961 + in 2962 2962 + if current_token parser = Token.LParen then begin 2963 2963 + advance parser; 2964 2964 + skip 1 2965 2965 + end else begin 2966 2966 + Lexer.restore parser.lexer saved_pos; 2967 2967 + parser.current <- saved_current; 2968 2968 + None 2969 2969 + end 2970 2970 + 1463 2971 and try_parse_arrow_params parser : Ast.pattern list option = 1464 2972 (* Try to convert current context to arrow parameters *) 1465 2973 (* This is called when we've seen ( and want to check for arrow *) 1466 2974 let saved_pos = Lexer.save parser.lexer in 1467 2975 let saved_current = parser.current in 2976 2976 + let saved_in_formal_parameters = parser.in_formal_parameters in 2977 2977 + (* Note: We do NOT reset in_static_block here. Arrow params should respect 2978 2978 + the static block context (await is reserved in static blocks). Only the 2979 2979 + arrow BODY resets in_static_block, handled in parse_arrow_body. *) 2980 2980 + (* Set in_formal_parameters to catch await/yield expressions in defaults *) 2981 2981 + parser.in_formal_parameters <- true; 1468 2982 try 1469 2983 expect parser Token.LParen; 1470 2984 let params = ref [] in 2985 2985 + let has_rest = ref false in 1471 2986 while current_token parser <> Token.RParen && not (is_at_end parser) do 1472 2987 if current_token parser = Token.Ellipsis then begin 2988 2988 + let rest_loc = current_loc parser in 1473 2989 advance parser; 1474 2990 let pat = parse_binding_pattern parser in 1475 1475 - params := Ast.mk_pat ~loc:pat.Ast.loc (Ast.Pat_rest pat) :: !params 2991 2991 + params := Ast.mk_pat ~loc:pat.Ast.loc (Ast.Pat_rest pat) :: !params; 2992 2992 + has_rest := true; 2993 2993 + (* Rest must be last - trailing comma not allowed *) 2994 2994 + if current_token parser = Token.Comma then 2995 2995 + raise (Parse_error (Rest_parameter_last, rest_loc)) 1476 2996 end else begin 1477 2997 let pat = parse_binding_pattern parser in 1478 2998 let pat = ··· 1489 3009 expect parser Token.Comma 1490 3010 done; 1491 3011 expect parser Token.RParen; 1492 1492 - if current_token parser = Token.Arrow then 1493 1493 - Some (List.rev !params) 1494 1494 - else begin 3012 3012 + if current_token parser = Token.Arrow && not parser.current.preceded_by_newline then begin 3013 3013 + parser.in_formal_parameters <- saved_in_formal_parameters; 3014 3014 + let params_list = List.rev !params in 3015 3015 + (* Arrow functions always use UniqueFormalParameters - duplicates are always forbidden *) 3016 3016 + check_duplicate_params parser params_list; 3017 3017 + Some params_list 3018 3018 + end else begin 3019 3019 + parser.in_formal_parameters <- saved_in_formal_parameters; 1495 3020 Lexer.restore parser.lexer saved_pos; 1496 3021 parser.current <- saved_current; 1497 3022 None 1498 3023 end 1499 1499 - with _ -> 3024 3024 + with 3025 3025 + | Parse_error _ -> 3026 3026 + (* We failed to parse as arrow params. This could mean: 3027 3027 + 1. It's not an arrow function at all (e.g., "(1 + 2)") 3028 3028 + 2. It's a nested arrow function inside parens (e.g., "(a => a + 1)") 3029 3029 + In both cases, restore state and return None to let caller parse as expression. *) 3030 3030 + parser.in_formal_parameters <- saved_in_formal_parameters; 3031 3031 + Lexer.restore parser.lexer saved_pos; 3032 3032 + parser.current <- saved_current; 3033 3033 + None 3034 3034 + | _ -> 3035 3035 + parser.in_formal_parameters <- saved_in_formal_parameters; 1500 3036 Lexer.restore parser.lexer saved_pos; 1501 3037 parser.current <- saved_current; 1502 3038 None ··· 1509 3045 | Token.Identifier "async" -> 1510 3046 let next = Lexer.peek parser.lexer in 1511 3047 (* async arrow function: no newline between async and param/params *) 1512 1512 - if not next.preceded_by_newline && (next.tok = Token.LParen || (match next.tok with Token.Identifier _ -> true | _ -> false)) then begin 1513 1513 - advance parser; (* consume async *) 1514 1514 - let async_loc = start_loc in 1515 1515 - (match current_token parser with 1516 1516 - | Token.Identifier name -> 1517 1517 - let next = Lexer.peek parser.lexer in 1518 1518 - (* No newline allowed before => *) 1519 1519 - if next.tok = Token.Arrow && not next.preceded_by_newline then begin 3048 3048 + if not next.preceded_by_newline && (next.tok = Token.LParen || (match next.tok with Token.Identifier _ | Token.Escaped_identifier _ -> true | _ -> false)) then begin 3049 3049 + (* For simple identifier case (async x => ...), we need to lookahead TWO tokens 3050 3050 + to see if there's an arrow. If not, we must NOT consume async. *) 3051 3051 + let is_arrow_case = 3052 3052 + match next.tok with 3053 3053 + | Token.LParen -> true (* async (...) always tries arrow parsing with backtracking *) 3054 3054 + | Token.Identifier _ | Token.Escaped_identifier _ -> 3055 3055 + (* async x => ... - need to check if third token is => *) 3056 3056 + let saved_pos = Lexer.save parser.lexer in 3057 3057 + let saved_current = parser.current in 3058 3058 + advance parser; (* consume async *) 3059 3059 + advance parser; (* consume identifier *) 3060 3060 + let third_tok = current_token parser in 3061 3061 + let is_arrow = (third_tok = Token.Arrow) && not parser.current.preceded_by_newline in 3062 3062 + (* Restore state *) 3063 3063 + Lexer.restore parser.lexer saved_pos; 3064 3064 + parser.current <- saved_current; 3065 3065 + is_arrow 3066 3066 + | _ -> false 3067 3067 + in 3068 3068 + if is_arrow_case then begin 3069 3069 + (* For LParen case, we need to save state before consuming async 3070 3070 + because try_parse_arrow_params might fail and we need to restore *) 3071 3071 + let saved_pos_before_async = Lexer.save parser.lexer in 3072 3072 + let saved_current_before_async = parser.current in 3073 3073 + advance parser; (* consume async *) 3074 3074 + let async_loc = start_loc in 3075 3075 + (match current_token parser with 3076 3076 + | Token.Identifier name | Token.Escaped_identifier name -> 3077 3077 + (* await/yield cannot be parameter names in async arrow functions *) 3078 3078 + if name = "await" then 3079 3079 + error parser (Strict_reserved_word "await"); 3080 3080 + if name = "yield" && parser.strict_mode then 3081 3081 + error parser (Strict_reserved_word "yield"); 1520 3082 let id_loc = current_loc parser in 1521 1521 - advance parser; 1522 1522 - let arrow = parse_arrow_function_body parser ~is_async:true in 3083 3083 + advance parser; (* consume identifier *) 1523 3084 let param = Ast.mk_pat ~loc:id_loc (Ast.Pat_identifier { Ast.name; loc = id_loc }) in 3085 3085 + let arrow = parse_arrow_function_body parser ~is_async:true ~params:[param] () in 1524 3086 let end_loc = match arrow.ar_body with 1525 3087 | Ast.Arrow_expression e -> e.Ast.loc 1526 3088 | Ast.Arrow_block b -> b.body_loc 1527 3089 in 1528 3090 let loc = Source.mk_loc ~start:async_loc.start ~end_:end_loc.end_ () in 1529 1529 - Ast.mk_expr ~loc (Ast.Arrow { arrow with ar_params = [param] }) 1530 1530 - end else 1531 1531 - parse_assignment_expression_rest parser start_loc 1532 1532 - | Token.LParen -> 1533 1533 - (match try_parse_arrow_params parser with 1534 1534 - | Some params -> 1535 1535 - let arrow = parse_arrow_function_body parser ~is_async:true in 1536 1536 - let end_loc = match arrow.ar_body with 1537 1537 - | Ast.Arrow_expression e -> e.Ast.loc 1538 1538 - | Ast.Arrow_block b -> b.body_loc 1539 1539 - in 1540 1540 - let loc = Source.mk_loc ~start:async_loc.start ~end_:end_loc.end_ () in 1541 1541 - Ast.mk_expr ~loc (Ast.Arrow { arrow with ar_params = params }) 1542 1542 - | None -> 3091 3091 + Ast.mk_expr ~loc (Ast.Arrow arrow) 3092 3092 + | Token.LParen -> 3093 3093 + (* Set in_async before parsing params so await is reserved in defaults *) 3094 3094 + let saved_in_async = parser.in_async in 3095 3095 + parser.in_async <- true; 3096 3096 + (match try_parse_arrow_params parser with 3097 3097 + | Some params -> 3098 3098 + parser.in_async <- saved_in_async; 3099 3099 + (* In async arrow, 'await' cannot be a parameter name *) 3100 3100 + List.iter (fun pat -> 3101 3101 + List.iter (fun (name, _loc) -> 3102 3102 + if name = "await" then 3103 3103 + error parser (Strict_reserved_word "await"); 3104 3104 + if name = "yield" && parser.strict_mode then 3105 3105 + error parser (Strict_reserved_word "yield") 3106 3106 + ) (collect_bound_names_from_pattern pat) 3107 3107 + ) params; 3108 3108 + let arrow = parse_arrow_function_body parser ~is_async:true ~params () in 3109 3109 + (* Check for "use strict" with non-simple params *) 3110 3110 + (match arrow.ar_body with 3111 3111 + | Ast.Arrow_block { body_directives; _ } when List.mem "use strict" body_directives -> 3112 3112 + if not (is_simple_parameter_list params) then 3113 3113 + error parser Use_strict_non_simple_params 3114 3114 + | _ -> ()); 3115 3115 + let end_loc = match arrow.ar_body with 3116 3116 + | Ast.Arrow_expression e -> e.Ast.loc 3117 3117 + | Ast.Arrow_block b -> b.body_loc 3118 3118 + in 3119 3119 + let loc = Source.mk_loc ~start:async_loc.start ~end_:end_loc.end_ () in 3120 3120 + Ast.mk_expr ~loc (Ast.Arrow arrow) 3121 3121 + | None -> 3122 3122 + parser.in_async <- saved_in_async; 3123 3123 + (* Restore to before async was consumed *) 3124 3124 + Lexer.restore parser.lexer saved_pos_before_async; 3125 3125 + parser.current <- saved_current_before_async; 3126 3126 + parse_assignment_expression_rest parser start_loc) 3127 3127 + | _ -> 1543 3128 parse_assignment_expression_rest parser start_loc) 1544 1544 - | _ -> 1545 1545 - parse_assignment_expression_rest parser start_loc) 3129 3129 + end else 3130 3130 + parse_assignment_expression_rest parser start_loc 1546 3131 end else 1547 3132 parse_assignment_expression_rest parser start_loc 1548 1548 - | Token.Identifier name -> 3133 3133 + | Token.Identifier name | Token.Escaped_identifier name -> 1549 3134 let next = Lexer.peek parser.lexer in 1550 3135 (* Arrow function: newline is NOT allowed before => *) 1551 3136 if next.tok = Token.Arrow && not next.preceded_by_newline then begin 3137 3137 + (* In strict mode, eval and arguments cannot be used as arrow parameter *) 3138 3138 + if parser.strict_mode && (name = "eval" || name = "arguments") then 3139 3139 + error parser (Strict_eval_arguments name); 1552 3140 advance parser; (* consume identifier *) 1553 1553 - let arrow = parse_arrow_function_body parser ~is_async:false in 1554 3141 let param = Ast.mk_pat ~loc:start_loc (Ast.Pat_identifier { Ast.name; loc = start_loc }) in 3142 3142 + let arrow = parse_arrow_function_body parser ~is_async:false ~params:[param] () in 1555 3143 let end_loc = match arrow.ar_body with 1556 3144 | Ast.Arrow_expression e -> e.Ast.loc 1557 3145 | Ast.Arrow_block b -> b.body_loc 1558 3146 in 1559 3147 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 1560 1560 - Ast.mk_expr ~loc (Ast.Arrow { arrow with ar_params = [param] }) 3148 3148 + Ast.mk_expr ~loc (Ast.Arrow arrow) 3149 3149 + end else 3150 3150 + parse_assignment_expression_rest parser start_loc 3151 3151 + | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode -> 3152 3152 + (* yield as arrow parameter: yield => 1 *) 3153 3153 + let next = Lexer.peek parser.lexer in 3154 3154 + if next.tok = Token.Arrow && not next.preceded_by_newline then begin 3155 3155 + advance parser; (* consume yield *) 3156 3156 + let param = Ast.mk_pat ~loc:start_loc (Ast.Pat_identifier { Ast.name = "yield"; loc = start_loc }) in 3157 3157 + let arrow = parse_arrow_function_body parser ~is_async:false ~params:[param] () in 3158 3158 + let end_loc = match arrow.ar_body with 3159 3159 + | Ast.Arrow_expression e -> e.Ast.loc 3160 3160 + | Ast.Arrow_block b -> b.body_loc 3161 3161 + in 3162 3162 + let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 3163 3163 + Ast.mk_expr ~loc (Ast.Arrow arrow) 3164 3164 + end else 3165 3165 + parse_assignment_expression_rest parser start_loc 3166 3166 + | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module && not parser.in_static_block -> 3167 3167 + (* await as arrow parameter: await => 1 (only in scripts, not async, not in static block) *) 3168 3168 + let next = Lexer.peek parser.lexer in 3169 3169 + if next.tok = Token.Arrow && not next.preceded_by_newline then begin 3170 3170 + advance parser; (* consume await *) 3171 3171 + let param = Ast.mk_pat ~loc:start_loc (Ast.Pat_identifier { Ast.name = "await"; loc = start_loc }) in 3172 3172 + let arrow = parse_arrow_function_body parser ~is_async:false ~params:[param] () in 3173 3173 + let end_loc = match arrow.ar_body with 3174 3174 + | Ast.Arrow_expression e -> e.Ast.loc 3175 3175 + | Ast.Arrow_block b -> b.body_loc 3176 3176 + in 3177 3177 + let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 3178 3178 + Ast.mk_expr ~loc (Ast.Arrow arrow) 1561 3179 end else 1562 3180 parse_assignment_expression_rest parser start_loc 1563 3181 | Token.LParen -> 1564 3182 (* Check if this is (params) => ... *) 1565 3183 (match try_parse_arrow_params parser with 1566 3184 | Some params -> 1567 1567 - let arrow = parse_arrow_function_body parser ~is_async:false in 3185 3185 + let arrow = parse_arrow_function_body parser ~is_async:false ~params () in 3186 3186 + (* Check for "use strict" with non-simple params *) 3187 3187 + (match arrow.ar_body with 3188 3188 + | Ast.Arrow_block { body_directives; _ } when List.mem "use strict" body_directives -> 3189 3189 + if not (is_simple_parameter_list params) then 3190 3190 + error parser Use_strict_non_simple_params 3191 3191 + | _ -> ()); 1568 3192 let end_loc = match arrow.ar_body with 1569 3193 | Ast.Arrow_expression e -> e.Ast.loc 1570 3194 | Ast.Arrow_block b -> b.body_loc 1571 3195 in 1572 3196 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 1573 1573 - Ast.mk_expr ~loc (Ast.Arrow { arrow with ar_params = params }) 3197 3197 + Ast.mk_expr ~loc (Ast.Arrow arrow) 1574 3198 | None -> 1575 3199 parse_assignment_expression_rest parser start_loc) 1576 3200 | _ -> ··· 1579 3203 and parse_assignment_expression_rest parser start_loc : Ast.expression = 1580 3204 let _ = start_loc in 1581 3205 if parser.in_generator && current_token parser = Token.Keyword Token.Kw_yield then begin 3206 3206 + (* YieldExpression is not allowed in formal parameters *) 3207 3207 + if parser.in_formal_parameters then 3208 3208 + error parser Yield_in_parameter; 1582 3209 let start_loc = current_loc parser in 1583 3210 advance parser; 3211 3211 + (* yield* - the * must not be preceded by newline *) 1584 3212 let delegate = 1585 1585 - if current_token parser = Token.Star then begin advance parser; true end else false 3213 3213 + if current_token parser = Token.Star && not parser.current.preceded_by_newline then begin advance parser; true end else false 1586 3214 in 1587 3215 let argument = 1588 3216 if can_start_expression parser && not parser.current.preceded_by_newline then ··· 1617 3245 match assign_op with 1618 3246 | Some operator -> 1619 3247 advance parser; 1620 1620 - let left_pat = expr_to_pattern left in 3248 3248 + (* Check for any assignment to eval/arguments in strict mode (both simple and compound) *) 3249 3249 + (if parser.strict_mode then 3250 3250 + let check_name name = name = "eval" || name = "arguments" in 3251 3251 + let rec check_simple_target e = 3252 3252 + match e.Ast.expr with 3253 3253 + | Ast.Identifier { name; _ } when check_name name -> 3254 3254 + error parser (Strict_eval_arguments name) 3255 3255 + | Ast.Paren inner -> check_simple_target inner 3256 3256 + | _ -> () 3257 3257 + in 3258 3258 + (* For simple assignment, only identifiers are checked (destructuring patterns have 3259 3259 + their own binding validation). For compound assignment, any simple target is checked. *) 3260 3260 + if operator = Ast.Assign then 3261 3261 + (* Simple assignment: check direct identifier only, not destructuring *) 3262 3262 + (match left.Ast.expr with 3263 3263 + | Ast.Identifier { name; _ } when check_name name -> 3264 3264 + error parser (Strict_eval_arguments name) 3265 3265 + | Ast.Paren inner -> check_simple_target inner 3266 3266 + | _ -> ()) 3267 3267 + else 3268 3268 + (* Compound assignment: check the target *) 3269 3269 + check_simple_target left); 3270 3270 + (* In non-strict mode, allow call expressions as assignment targets (Annex B web compat) 3271 3271 + but NOT for logical assignment operators (&&=, ||=, ??=) which always require simple targets *) 3272 3272 + let is_logical_assign = match operator with 3273 3273 + | Ast.Or_assign | Ast.And_assign | Ast.Nullish_assign -> true 3274 3274 + | _ -> false 3275 3275 + in 3276 3276 + let left_pat = expr_to_pattern ~allow_call:(not parser.strict_mode && not is_logical_assign) left in 3277 3277 + (* Validate that assignment pattern doesn't contain eval/arguments as targets in strict mode *) 3278 3278 + validate_assignment_pattern_strict parser left_pat; 1621 3279 let right = parse_assignment_expression parser in 1622 3280 let loc = Source.mk_loc ~start:left.Ast.loc.start ~end_:right.Ast.loc.end_ () in 1623 3281 Ast.mk_expr ~loc (Ast.Assignment { operator; left = left_pat; right }) ··· 1639 3297 end else 1640 3298 expr 1641 3299 3300 3300 + (* Helper to collect all bound names from a pattern *) 3301 3301 + and collect_bound_names (pat : Ast.pattern) : string list = 3302 3302 + let rec collect acc (p : Ast.pattern) = 3303 3303 + match p.Ast.pat with 3304 3304 + | Ast.Pat_identifier id -> id.Ast.name :: acc 3305 3305 + | Ast.Pat_array elems -> 3306 3306 + List.fold_left (fun acc elem -> 3307 3307 + match elem with 3308 3308 + | Some (Ast.Array_pat_element p) -> collect acc p 3309 3309 + | Some (Ast.Array_pat_rest p) -> collect acc p 3310 3310 + | None -> acc 3311 3311 + ) acc elems 3312 3312 + | Ast.Pat_object props -> 3313 3313 + List.fold_left (fun acc prop -> 3314 3314 + match prop with 3315 3315 + | Ast.Object_pat_property { value; _ } -> collect acc value 3316 3316 + | Ast.Object_pat_rest p -> collect acc p 3317 3317 + ) acc props 3318 3318 + | Ast.Pat_assignment { left; _ } -> collect acc left 3319 3319 + | Ast.Pat_rest p -> collect acc p 3320 3320 + | _ -> acc 3321 3321 + in 3322 3322 + collect [] pat 3323 3323 + 3324 3324 + (* Helper to check if a pattern contains 'let' as a binding name or duplicates *) 3325 3325 + and check_lexical_binding parser (pat : Ast.pattern) = 3326 3326 + let names = collect_bound_names pat in 3327 3327 + (* Check for 'let' *) 3328 3328 + if List.mem "let" names then error parser Let_in_lexical_binding; 3329 3329 + (* Check for duplicates *) 3330 3330 + let rec check_dup = function 3331 3331 + | [] -> () 3332 3332 + | name :: rest -> 3333 3333 + if List.mem name rest then error parser (Duplicate_binding name); 3334 3334 + check_dup rest 3335 3335 + in 3336 3336 + check_dup names 3337 3337 + 1642 3338 and parse_variable_declaration parser kind : Ast.var_declaration = 1643 3339 let start_loc = current_loc parser in 3340 3340 + let bind_kind = match kind with 3341 3341 + | Ast.Var -> Bind_var 3342 3342 + | Ast.Let -> Bind_let 3343 3343 + | Ast.Const -> Bind_const 3344 3344 + | Ast.Using | Ast.Await_using -> Bind_const (* using/await using behave like const *) 3345 3345 + in 1644 3346 let declarations = ref [] in 1645 3347 let rec loop () = 1646 3348 let id = parse_binding_pattern parser in 3349 3349 + (* Check that 'let' is not used as a binding name in let/const/using/await-using declarations, 3350 3350 + and check for duplicate bindings in destructuring *) 3351 3351 + (match kind with 3352 3352 + | Ast.Let | Ast.Const | Ast.Using | Ast.Await_using -> check_lexical_binding parser id 3353 3353 + | _ -> ()); 3354 3354 + (* Add bindings to scope for redeclaration detection *) 3355 3355 + add_pattern_bindings parser bind_kind id; 1647 3356 let init = 1648 3357 if current_token parser = Token.Eq then begin 1649 3358 advance parser; ··· 1666 3375 let var_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 1667 3376 { Ast.var_kind = kind; var_declarations = List.rev !declarations; var_loc } 1668 3377 3378 3378 + (* Check that const/using/await-using have initializers in statement context *) 3379 3379 + and check_const_initializers parser (decl : Ast.var_declaration) = 3380 3380 + match decl.var_kind with 3381 3381 + | Ast.Const | Ast.Using | Ast.Await_using -> 3382 3382 + List.iter (fun d -> 3383 3383 + if d.Ast.var_init = None then 3384 3384 + error parser Const_no_initializer 3385 3385 + ) decl.var_declarations 3386 3386 + | _ -> () 3387 3387 + 1669 3388 and parse_block_statement parser : Ast.statement = 1670 3389 let start_loc = current_loc parser in 1671 3390 expect parser Token.LBrace; 3391 3391 + push_scope parser ~is_function:false; 3392 3392 + (* Block statements allow using declarations *) 3393 3393 + let saved_in_block = parser.in_block in 3394 3394 + parser.in_block <- true; 1672 3395 let stmts = ref [] in 1673 1673 - while current_token parser <> Token.RBrace && not (is_at_end parser) do 1674 1674 - stmts := parse_statement parser :: !stmts 1675 1675 - done; 3396 3396 + (try 3397 3397 + while current_token parser <> Token.RBrace && not (is_at_end parser) do 3398 3398 + stmts := parse_statement parser :: !stmts 3399 3399 + done 3400 3400 + with e -> 3401 3401 + parser.in_block <- saved_in_block; 3402 3402 + pop_scope parser; 3403 3403 + raise e); 3404 3404 + parser.in_block <- saved_in_block; 3405 3405 + pop_scope parser; 1676 3406 let end_loc = current_loc parser in 1677 3407 expect parser Token.RBrace; 1678 3408 (* After block statement, regex is allowed (not division) *) ··· 1680 3410 let loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 1681 3411 Ast.mk_stmt ~loc (Ast.Block (List.rev !stmts)) 1682 3412 3413 3413 + (* Parse a single statement in a context where using declarations are not allowed 3414 3414 + (e.g., if consequent, while body, for body, labeled statement, etc.) 3415 3415 + The statement can be a block { }, in which case parse_block_statement sets in_block=true. *) 3416 3416 + and parse_single_statement parser = 3417 3417 + let saved_in_block = parser.in_block in 3418 3418 + parser.in_block <- false; 3419 3419 + let stmt = 3420 3420 + try parse_statement parser 3421 3421 + with e -> 3422 3422 + parser.in_block <- saved_in_block; 3423 3423 + raise e 3424 3424 + in 3425 3425 + parser.in_block <- saved_in_block; 3426 3426 + stmt 3427 3427 + 3428 3428 + (* Check if statement is allowed in single-statement context. 3429 3429 + - In strict mode or for loops/while: no function declarations at all 3430 3430 + - In non-strict if statements: plain functions allowed (Annex B) but not async/generators/class/let/const 3431 3431 + - Labelled functions follow labelled statement rules (handled separately) *) 3432 3432 + and check_single_statement_body parser ?(allow_function_annex_b=false) (body : Ast.statement) = 3433 3433 + match body.Ast.stmt with 3434 3434 + | Ast.Function { fd_async = true; _ } | Ast.Function { fd_generator = true; _ } -> 3435 3435 + (* Async functions and generators never allowed *) 3436 3436 + error parser Function_in_single_statement 3437 3437 + | Ast.Function _ when parser.strict_mode || not allow_function_annex_b -> 3438 3438 + (* Plain functions: only allowed in non-strict if statement (Annex B) *) 3439 3439 + error parser Function_in_single_statement 3440 3440 + | Ast.Class _ | Ast.Variable { var_kind = (Ast.Let | Ast.Const); _ } -> 3441 3441 + (* Class and lexical declarations never allowed *) 3442 3442 + error parser Function_in_single_statement 3443 3443 + | Ast.Labeled { body; _ } -> 3444 3444 + (* Check if the labelled body is a function (IsLabelledFunction) *) 3445 3445 + let rec is_labelled_function (s : Ast.statement) = 3446 3446 + match s.Ast.stmt with 3447 3447 + | Ast.Function _ -> true 3448 3448 + | Ast.Labeled { body; _ } -> is_labelled_function body 3449 3449 + | _ -> false 3450 3450 + in 3451 3451 + if is_labelled_function body then 3452 3452 + error parser Function_in_single_statement 3453 3453 + | _ -> () 3454 3454 + 1683 3455 and parse_if_statement parser : Ast.statement = 1684 3456 let start_loc = current_loc parser in 1685 3457 expect parser (Token.Keyword Token.Kw_if); 1686 3458 expect parser Token.LParen; 1687 3459 let test = parse_expression parser in 1688 3460 expect parser Token.RParen; 1689 1689 - let consequent = parse_statement parser in 3461 3461 + (* In sloppy mode, function declarations in if/else get an implicit scope (Annex B) *) 3462 3462 + let parse_if_body () = 3463 3463 + let is_function_decl = match current_token parser with 3464 3464 + | Token.Keyword Token.Kw_function -> true 3465 3465 + | Token.Identifier "async" when (Lexer.peek parser.lexer).tok = Token.Keyword Token.Kw_function -> true 3466 3466 + | _ -> false 3467 3467 + in 3468 3468 + if not parser.strict_mode && is_function_decl then begin 3469 3469 + push_scope parser ~is_function:false; 3470 3470 + let body = parse_single_statement parser in 3471 3471 + pop_scope parser; 3472 3472 + body 3473 3473 + end else 3474 3474 + parse_single_statement parser 3475 3475 + in 3476 3476 + let consequent = parse_if_body () in 3477 3477 + (* Check if body is allowed - plain functions ok in non-strict (Annex B) *) 3478 3478 + check_single_statement_body parser ~allow_function_annex_b:true consequent; 1690 3479 let alternate = 1691 3480 if current_token parser = Token.Keyword Token.Kw_else then begin 1692 3481 advance parser; 1693 1693 - Some (parse_statement parser) 3482 3482 + let alt = parse_if_body () in 3483 3483 + check_single_statement_body parser ~allow_function_annex_b:true alt; 3484 3484 + Some alt 1694 3485 end else 1695 3486 None 1696 3487 in ··· 1709 3500 expect parser Token.RParen; 1710 3501 let saved_in_iteration = parser.in_iteration in 1711 3502 parser.in_iteration <- true; 1712 1712 - let body = parse_statement parser in 3503 3503 + let body = parse_single_statement parser in 1713 3504 parser.in_iteration <- saved_in_iteration; 3505 3505 + (* Check body - no Annex B exception for while *) 3506 3506 + check_single_statement_body parser body; 1714 3507 let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 1715 3508 Ast.mk_stmt ~loc (Ast.While { test; body }) 1716 3509 ··· 1737 3530 parser.allow_in <- saved_allow_in; 1738 3531 e 1739 3532 in 3533 3533 + (* Parse variables with allow_in=false so initializers stop at 'in' *) 3534 3534 + let parse_var_decl kind = 3535 3535 + let saved_allow_in = parser.allow_in in 3536 3536 + parser.allow_in <- false; 3537 3537 + let decl = parse_variable_declaration parser kind in 3538 3538 + parser.allow_in <- saved_allow_in; 3539 3539 + decl 3540 3540 + in 3541 3541 + (* Track whether we need a for-scope for lexical declarations *) 3542 3542 + let has_lexical_scope = ref false in 1740 3543 let init = 1741 3544 match current_token parser with 1742 3545 | Token.Semicolon -> None 1743 3546 | Token.Keyword Token.Kw_var -> 1744 3547 advance parser; 1745 1745 - Some (Ast.For_init_var (parse_variable_declaration parser Ast.Var)) 3548 3548 + Some (Ast.For_init_var (parse_var_decl Ast.Var)) 1746 3549 | Token.Keyword Token.Kw_let -> 1747 1747 - (* In non-strict mode, 'let' is only a keyword if followed by [ or binding name 1748 1748 - Otherwise it's an identifier expression *) 3550 3550 + (* In non-strict mode: 3551 3551 + - 'let [' or 'let {' is ALWAYS a declaration (even with newline) 3552 3552 + - 'let <identifier>' with newline: 'let' becomes an identifier 3553 3553 + - 'let <identifier>' without newline: is a declaration *) 1749 3554 let next = Lexer.peek parser.lexer in 1750 3555 let is_binding_start = match next.tok with 3556 3556 + (* [ and { are always binding start, even across newlines *) 1751 3557 | Token.LBracket | Token.LBrace -> true 1752 1752 - | Token.Identifier _ -> true 3558 3558 + (* Identifiers only count as binding start without newline *) 3559 3559 + | Token.Identifier _ | Token.Escaped_identifier _ -> not next.preceded_by_newline 3560 3560 + (* 'let' is always a binding start (must be before is_strict_reserved) - will error as lexical binding name *) 3561 3561 + | Token.Keyword Token.Kw_let -> true 1753 3562 (* Keywords that can be binding names in non-strict mode *) 1754 1754 - | Token.Keyword kw when is_strict_reserved kw -> true 1755 1755 - | Token.Keyword Token.Kw_yield -> not parser.in_generator 1756 1756 - | Token.Keyword Token.Kw_await -> not parser.in_async && not parser.in_module 3563 3563 + | Token.Keyword kw when is_strict_reserved kw -> not next.preceded_by_newline 3564 3564 + (* yield/await: ASI should never apply between let and these keywords *) 3565 3565 + | Token.Keyword Token.Kw_yield -> true 3566 3566 + | Token.Keyword Token.Kw_await -> true 1757 3567 | _ -> false 1758 3568 in 1759 3569 if parser.strict_mode || is_binding_start then begin 3570 3570 + (* Push scope for lexical binding in for loop *) 3571 3571 + push_scope parser ~is_function:false; 3572 3572 + has_lexical_scope := true; 1760 3573 advance parser; 1761 1761 - Some (Ast.For_init_var (parse_variable_declaration parser Ast.Let)) 3574 3574 + Some (Ast.For_init_var (parse_var_decl Ast.Let)) 1762 3575 end else 1763 3576 (* 'let' is an identifier in non-strict mode *) 1764 3577 Some (Ast.For_init_expr (parse_expr_no_in ())) 1765 3578 | Token.Keyword Token.Kw_const -> 3579 3579 + (* Push scope for lexical binding in for loop *) 3580 3580 + push_scope parser ~is_function:false; 3581 3581 + has_lexical_scope := true; 1766 3582 advance parser; 1767 1767 - Some (Ast.For_init_var (parse_variable_declaration parser Ast.Const)) 1768 1768 - | Token.Identifier "using" -> 3583 3583 + Some (Ast.For_init_var (parse_var_decl Ast.Const)) 3584 3584 + | Token.Identifier "using" | Token.Escaped_identifier "using" -> 1769 3585 (* Check if this is 'using x of ...' or 'using' as an expression *) 1770 3586 let next = Lexer.peek parser.lexer in 1771 3587 (match next.tok with 1772 1772 - | Token.Identifier _ | Token.LBracket | Token.LBrace -> 1773 1773 - (* 'using' declaration *) 3588 3588 + | Token.Identifier _ | Token.Escaped_identifier _ | Token.LBracket | Token.LBrace -> 3589 3589 + (* 'using' declaration - push scope *) 3590 3590 + push_scope parser ~is_function:false; 3591 3591 + has_lexical_scope := true; 1774 3592 advance parser; 1775 1775 - Some (Ast.For_init_var (parse_variable_declaration parser Ast.Using)) 3593 3593 + Some (Ast.For_init_var (parse_var_decl Ast.Using)) 1776 3594 | _ -> 1777 3595 (* 'using' as an identifier in expression *) 1778 3596 Some (Ast.For_init_expr (parse_expr_no_in ()))) ··· 1780 3598 (* Check for 'await using' declaration *) 1781 3599 let next = Lexer.peek parser.lexer in 1782 3600 (match next.tok with 1783 1783 - | Token.Identifier "using" -> 3601 3601 + | Token.Identifier "using" | Token.Escaped_identifier "using" -> 3602 3602 + (* 'await using' declaration - push scope *) 3603 3603 + push_scope parser ~is_function:false; 3604 3604 + has_lexical_scope := true; 1784 3605 advance parser; (* skip 'await' *) 1785 3606 advance parser; (* skip 'using' *) 1786 1786 - Some (Ast.For_init_var (parse_variable_declaration parser Ast.Await_using)) 3607 3607 + Some (Ast.For_init_var (parse_var_decl Ast.Await_using)) 1787 3608 | _ -> 1788 3609 (* Just an await expression *) 1789 3610 Some (Ast.For_init_expr (parse_expr_no_in ()))) 3611 3611 + | Token.Identifier "async" when not is_await -> 3612 3612 + (* Check for "async of" which is disallowed per spec lookahead restriction: 3613 3613 + [lookahead ∉ { let, async of }] - only for for-of, not for-await-of 3614 3614 + Note: escaped identifiers (\u0061sync) are NOT the keyword, so they are allowed 3615 3615 + Also: "async of =>" is an arrow function, which is allowed *) 3616 3616 + let peek1 = Lexer.peek parser.lexer in 3617 3617 + let is_async_of = 3618 3618 + (peek1.tok = Token.Identifier "of" || peek1.tok = Token.Keyword Token.Kw_of) 3619 3619 + in 3620 3620 + if is_async_of then begin 3621 3621 + let peek2 = Lexer.peek2 parser.lexer in 3622 3622 + if peek2.tok <> Token.Arrow then 3623 3623 + error parser Invalid_lhs_in_for 3624 3624 + end; 3625 3625 + Some (Ast.For_init_expr (parse_expr_no_in ())) 1790 3626 | _ -> 1791 3627 Some (Ast.For_init_expr (parse_expr_no_in ())) 1792 3628 in ··· 1795 3631 | Token.Keyword Token.Kw_in -> 1796 3632 advance parser; 1797 3633 let left = match init with 1798 1798 - | Some (Ast.For_init_var decl) -> Ast.For_in_var decl 1799 1799 - | Some (Ast.For_init_expr e) -> Ast.For_in_pat (expr_to_pattern e) 3634 3634 + | Some (Ast.For_init_var decl) -> 3635 3635 + (* Check no initializer for for-in - except for var in non-strict mode (Annex B) *) 3636 3636 + List.iter (fun d -> 3637 3637 + if d.Ast.var_init <> None then begin 3638 3638 + (* Annex B allows var initializers in for-in in non-strict mode, 3639 3639 + but only for simple identifier bindings, not destructuring *) 3640 3640 + let is_simple_id = match d.Ast.var_id.pat with 3641 3641 + | Ast.Pat_identifier _ -> true 3642 3642 + | _ -> false 3643 3643 + in 3644 3644 + if not (decl.var_kind = Ast.Var && not parser.strict_mode && is_simple_id) then 3645 3645 + error parser For_in_of_const_no_init 3646 3646 + end 3647 3647 + ) decl.var_declarations; 3648 3648 + (* using/await-using not allowed in for-in *) 3649 3649 + if decl.var_kind = Ast.Using || decl.var_kind = Ast.Await_using then 3650 3650 + error parser Using_in_for_in; 3651 3651 + (* Only one binding allowed in for-in *) 3652 3652 + if List.length decl.var_declarations > 1 then 3653 3653 + error parser Multiple_bindings_in_for; 3654 3654 + Ast.For_in_var decl 3655 3655 + | Some (Ast.For_init_expr e) -> 3656 3656 + (* Assignment expressions not allowed as for-in/of left side *) 3657 3657 + (match e.Ast.expr with 3658 3658 + | Ast.Assignment _ -> error parser Invalid_lhs_in_for 3659 3659 + | _ -> ()); 3660 3660 + let pat = expr_to_pattern ~allow_call:(not parser.strict_mode) e in 3661 3661 + validate_assignment_pattern_strict parser pat; 3662 3662 + Ast.For_in_pat pat 1800 3663 | None -> error parser Expected_expression 1801 3664 in 1802 3665 let right = parse_expression parser in 1803 3666 expect parser Token.RParen; 1804 3667 let saved_in_iteration = parser.in_iteration in 1805 3668 parser.in_iteration <- true; 1806 1806 - let body = parse_statement parser in 3669 3669 + let body = parse_single_statement parser in 1807 3670 parser.in_iteration <- saved_in_iteration; 3671 3671 + (* Check body - no Annex B exception for for-in *) 3672 3672 + check_single_statement_body parser body; 3673 3673 + (* Pop lexical scope if we pushed one *) 3674 3674 + if !has_lexical_scope then pop_scope parser; 1808 3675 let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 1809 3676 Ast.mk_stmt ~loc (Ast.For_in { left; right; body }) 1810 3677 1811 1811 - | Token.Identifier "of" -> 3678 3678 + | Token.Identifier "of" | Token.Keyword Token.Kw_of -> 1812 3679 advance parser; 1813 3680 let left = match init with 1814 1814 - | Some (Ast.For_init_var decl) -> Ast.For_in_var decl 1815 1815 - | Some (Ast.For_init_expr e) -> Ast.For_in_pat (expr_to_pattern e) 3681 3681 + | Some (Ast.For_init_var decl) -> 3682 3682 + (* Check no initializer for for-of *) 3683 3683 + List.iter (fun d -> 3684 3684 + if d.Ast.var_init <> None then 3685 3685 + error parser For_in_of_const_no_init 3686 3686 + ) decl.var_declarations; 3687 3687 + (* Only one binding allowed in for-of *) 3688 3688 + if List.length decl.var_declarations > 1 then 3689 3689 + error parser Multiple_bindings_in_for; 3690 3690 + Ast.For_in_var decl 3691 3691 + | Some (Ast.For_init_expr e) -> 3692 3692 + (* Assignment expressions not allowed as for-of left side *) 3693 3693 + (match e.Ast.expr with 3694 3694 + | Ast.Assignment _ -> error parser Invalid_lhs_in_for 3695 3695 + | _ -> ()); 3696 3696 + let pat = expr_to_pattern ~allow_call:(not parser.strict_mode) e in 3697 3697 + validate_assignment_pattern_strict parser pat; 3698 3698 + Ast.For_in_pat pat 1816 3699 | None -> error parser Expected_expression 1817 3700 in 1818 3701 let right = parse_assignment_expression parser in 1819 3702 expect parser Token.RParen; 1820 3703 let saved_in_iteration = parser.in_iteration in 1821 3704 parser.in_iteration <- true; 1822 1822 - let body = parse_statement parser in 3705 3705 + let body = parse_single_statement parser in 1823 3706 parser.in_iteration <- saved_in_iteration; 3707 3707 + (* Check body - no Annex B exception for for-of *) 3708 3708 + check_single_statement_body parser body; 3709 3709 + (* Pop lexical scope if we pushed one *) 3710 3710 + if !has_lexical_scope then pop_scope parser; 1824 3711 let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 1825 3712 Ast.mk_stmt ~loc (Ast.For_of { left; right; body; await = is_await }) 1826 3713 ··· 1838 3725 expect parser Token.RParen; 1839 3726 let saved_in_iteration = parser.in_iteration in 1840 3727 parser.in_iteration <- true; 1841 1841 - let body = parse_statement parser in 3728 3728 + let body = parse_single_statement parser in 1842 3729 parser.in_iteration <- saved_in_iteration; 3730 3730 + (* Check body - no Annex B exception for regular for *) 3731 3731 + check_single_statement_body parser body; 3732 3732 + (* Pop lexical scope if we pushed one *) 3733 3733 + if !has_lexical_scope then pop_scope parser; 1843 3734 let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 1844 3735 Ast.mk_stmt ~loc (Ast.For { init; test; update; body }) 1845 3736 ··· 1856 3747 advance parser; 1857 3748 let p = parse_binding_pattern parser in 1858 3749 expect parser Token.RParen; 3750 3750 + (* Check for duplicate names in catch parameter pattern *) 3751 3751 + let param_names = collect_bound_names_from_pattern p in 3752 3752 + let seen = ref [] in 3753 3753 + List.iter (fun (name, _loc) -> 3754 3754 + if List.mem name !seen then 3755 3755 + error parser (Duplicate_parameter name) 3756 3756 + else 3757 3757 + seen := name :: !seen 3758 3758 + ) param_names; 1859 3759 Some p 1860 3760 end else 1861 3761 None 1862 3762 in 1863 1863 - let catch_body = parse_block_statement parser in 3763 3763 + (* Push scope for catch block with catch parameter bindings *) 3764 3764 + push_scope parser ~is_function:false; 3765 3765 + (match catch_param with 3766 3766 + | Some p -> 3767 3767 + let param_names = collect_bound_names_from_pattern p in 3768 3768 + List.iter (fun (name, loc) -> 3769 3769 + add_binding parser name Bind_catch loc 3770 3770 + ) param_names 3771 3771 + | None -> ()); 3772 3772 + (* Parse catch body block - but DON'T create a new scope since catch param 3773 3773 + and body share the same scope per spec. *) 3774 3774 + let body_start = current_loc parser in 3775 3775 + expect parser Token.LBrace; 3776 3776 + let saved_in_block = parser.in_block in 3777 3777 + parser.in_block <- true; 3778 3778 + let stmts = ref [] in 3779 3779 + (try 3780 3780 + while current_token parser <> Token.RBrace && not (is_at_end parser) do 3781 3781 + stmts := parse_statement parser :: !stmts 3782 3782 + done 3783 3783 + with e -> 3784 3784 + parser.in_block <- saved_in_block; 3785 3785 + pop_scope parser; 3786 3786 + raise e); 3787 3787 + parser.in_block <- saved_in_block; 3788 3788 + pop_scope parser; 3789 3789 + let body_end = current_loc parser in 3790 3790 + expect parser Token.RBrace; 3791 3791 + let body_loc = Source.mk_loc ~start:body_start.start ~end_:body_end.end_ () in 3792 3792 + let catch_body = Ast.mk_stmt ~loc:body_loc (Ast.Block (List.rev !stmts)) in 1864 3793 Some { Ast.catch_param; catch_body; catch_loc } 1865 3794 end else 1866 3795 None ··· 1885 3814 let is_generator = current_token parser = Token.Star in 1886 3815 if is_generator then advance parser; 1887 3816 let fd_id = parse_identifier parser in 1888 1888 - let fn = parse_function_body parser ~is_generator ~is_async:false in 3817 3817 + (* In strict mode, 'eval' and 'arguments' are not allowed as function names *) 3818 3818 + if parser.strict_mode && (fd_id.name = "eval" || fd_id.name = "arguments") then 3819 3819 + error parser (Strict_eval_arguments fd_id.name); 3820 3820 + (* Add function name to scope for redeclaration detection. 3821 3821 + Generator functions use Bind_generator_or_async since they're always lexical. *) 3822 3822 + let bind_kind = if is_generator then Bind_generator_or_async else Bind_function in 3823 3823 + add_binding parser fd_id.name bind_kind fd_id.loc; 3824 3824 + let fn = parse_function_body parser ~is_generator ~is_async:false ~fn_name:fd_id () in 1889 3825 let fd_loc = Source.mk_loc ~start:start_loc.start ~end_:fn.fn_body.body_loc.end_ () in 1890 3826 { 1891 3827 Ast.fd_id; ··· 1913 3849 Ast.mk_stmt ~loc:decl.var_loc (Ast.Variable decl) 1914 3850 1915 3851 | Token.Keyword Token.Kw_let -> 1916 1916 - (* In non-strict mode, 'let' followed by [ or binding name is a declaration 1917 1917 - Otherwise 'let' might be an identifier expression statement *) 3852 3852 + (* In non-strict mode: 3853 3853 + - 'let [' is ALWAYS a declaration (even with newline, per spec syntax restriction) 3854 3854 + - 'let {' with newline: ASI applies, 'let' is an identifier 3855 3855 + - 'let {' without newline: is a declaration (destructuring) 3856 3856 + - 'let <identifier>' with newline: 'let' becomes an identifier 3857 3857 + - 'let <identifier>' without newline: is a declaration *) 1918 3858 let next = Lexer.peek parser.lexer in 1919 3859 let is_binding_start = match next.tok with 1920 1920 - | Token.LBracket | Token.LBrace -> true 1921 1921 - | Token.Identifier _ -> true 3860 3860 + (* [ is ALWAYS a binding start, even across newlines (syntax restriction) *) 3861 3861 + | Token.LBracket -> true 3862 3862 + (* { is only a binding start without newline (ASI takes precedence) *) 3863 3863 + | Token.LBrace -> not next.preceded_by_newline 3864 3864 + (* Identifiers only count as binding start without newline *) 3865 3865 + | Token.Identifier _ | Token.Escaped_identifier _ -> not next.preceded_by_newline 3866 3866 + (* 'let' is always a binding start (even across newlines) because there's no 3867 3867 + [no LineTerminator here] restriction and 'let' will error as lexical binding name. 3868 3868 + This must be checked BEFORE is_strict_reserved which would require no newline. *) 3869 3869 + | Token.Keyword Token.Kw_let -> true 1922 3870 (* Keywords that can be binding names in non-strict mode *) 1923 1923 - | Token.Keyword kw when is_strict_reserved kw -> true 1924 1924 - | Token.Keyword Token.Kw_yield -> not parser.in_generator 1925 1925 - | Token.Keyword Token.Kw_await -> not parser.in_async && not parser.in_module 3871 3871 + | Token.Keyword kw when is_strict_reserved kw -> not next.preceded_by_newline 3872 3872 + (* yield/await: ASI should never apply between let and these keywords. 3873 3873 + They're syntactically valid as binding names, static semantics catch errors later. *) 3874 3874 + | Token.Keyword Token.Kw_yield -> true 3875 3875 + | Token.Keyword Token.Kw_await -> true 1926 3876 | _ -> false 1927 3877 in 1928 3878 if parser.strict_mode || is_binding_start then begin ··· 1940 3890 | Token.Keyword Token.Kw_const -> 1941 3891 advance parser; 1942 3892 let decl = parse_variable_declaration parser Ast.Const in 3893 3893 + check_const_initializers parser decl; 1943 3894 expect_semicolon parser; 1944 3895 Ast.mk_stmt ~loc:decl.var_loc (Ast.Variable decl) 1945 3896 1946 1946 - | Token.Identifier "using" -> 3897 3897 + | Token.Identifier "using" | Token.Escaped_identifier "using" -> 1947 3898 (* Check if this is 'using x' declaration or 'using' as identifier *) 1948 3899 let next = Lexer.peek parser.lexer in 1949 3900 (match next.tok with 1950 1950 - | Token.Identifier _ | Token.LBracket | Token.LBrace 3901 3901 + (* NOTE: LBracket is NOT included here because 'using[x]' is element access, not declaration. 3902 3902 + using declarations require simple identifier bindings - destructuring is forbidden. 3903 3903 + LBrace is for object pattern which would be caught by check_using_bindings_are_identifiers. *) 3904 3904 + | Token.Identifier _ | Token.Escaped_identifier _ | Token.LBrace 1951 3905 when not next.preceded_by_newline -> 1952 1952 - (* 'using' declaration *) 3906 3906 + (* 'using' declaration - not allowed at top level of Script or outside blocks *) 3907 3907 + if not parser.in_module && List.length parser.scopes = 1 then 3908 3908 + error parser Using_at_script_top_level; 3909 3909 + if not parser.in_block then 3910 3910 + error parser Using_not_in_block; 1953 3911 advance parser; 1954 3912 let decl = parse_variable_declaration parser Ast.Using in 3913 3913 + check_const_initializers parser decl; 3914 3914 + check_using_bindings_are_identifiers decl; 1955 3915 expect_semicolon parser; 1956 3916 Ast.mk_stmt ~loc:decl.var_loc (Ast.Variable decl) 1957 3917 | _ -> ··· 1962 3922 1963 3923 | Token.Keyword Token.Kw_await when 1964 3924 (let next = Lexer.peek parser.lexer in 1965 1965 - next.tok = Token.Identifier "using" && not next.preceded_by_newline) -> 1966 1966 - (* 'await using' declaration *) 3925 3925 + (next.tok = Token.Identifier "using" || next.tok = Token.Escaped_identifier "using") && not next.preceded_by_newline) -> 3926 3926 + (* Check if this is 'await using' declaration or 'await using[x]' expression *) 3927 3927 + let saved_pos = Lexer.save parser.lexer in 3928 3928 + let saved_current = parser.current in 1967 3929 advance parser; (* skip 'await' *) 1968 3930 advance parser; (* skip 'using' *) 1969 1969 - let decl = parse_variable_declaration parser Ast.Await_using in 1970 1970 - expect_semicolon parser; 1971 1971 - Ast.mk_stmt ~loc:decl.var_loc (Ast.Variable decl) 3931 3931 + (* Peek what comes after 'using' *) 3932 3932 + (match current_token parser with 3933 3933 + | Token.LBracket -> 3934 3934 + (* Could be array destructuring [x] = y or element access using[x] 3935 3935 + Destructuring REQUIRES an initializer, so check for '=' after ']' *) 3936 3936 + (* For simplicity, treat as expression - 'await (using[...])' *) 3937 3937 + Lexer.restore parser.lexer saved_pos; 3938 3938 + parser.current <- saved_current; 3939 3939 + let expr = parse_expression parser in 3940 3940 + expect_semicolon parser; 3941 3941 + Ast.mk_stmt ~loc:expr.Ast.loc (Ast.Expression expr) 3942 3942 + | Token.Identifier _ | Token.Escaped_identifier _ | Token.LBrace -> 3943 3943 + (* Valid binding start - parse as declaration. 3944 3944 + await using is also not allowed at top level of Script or outside blocks. *) 3945 3945 + if not parser.in_module && List.length parser.scopes = 1 then 3946 3946 + error parser Using_at_script_top_level; 3947 3947 + if not parser.in_block then 3948 3948 + error parser Using_not_in_block; 3949 3949 + let decl = parse_variable_declaration parser Ast.Await_using in 3950 3950 + check_const_initializers parser decl; 3951 3951 + check_using_bindings_are_identifiers decl; 3952 3952 + expect_semicolon parser; 3953 3953 + Ast.mk_stmt ~loc:decl.var_loc (Ast.Variable decl) 3954 3954 + | _ -> 3955 3955 + (* Not a valid binding start, restore and parse as expression *) 3956 3956 + Lexer.restore parser.lexer saved_pos; 3957 3957 + parser.current <- saved_current; 3958 3958 + let expr = parse_expression parser in 3959 3959 + expect_semicolon parser; 3960 3960 + Ast.mk_stmt ~loc:expr.Ast.loc (Ast.Expression expr)) 1972 3961 1973 3962 | Token.Keyword Token.Kw_if -> 1974 3963 parse_if_statement parser ··· 1983 3972 advance parser; 1984 3973 let saved_in_iteration = parser.in_iteration in 1985 3974 parser.in_iteration <- true; 1986 1986 - let body = parse_statement parser in 3975 3975 + let body = parse_single_statement parser in 1987 3976 parser.in_iteration <- saved_in_iteration; 3977 3977 + (* Check body - no Annex B exception for do-while *) 3978 3978 + check_single_statement_body parser body; 1988 3979 expect parser (Token.Keyword Token.Kw_while); 1989 3980 expect parser Token.LParen; 1990 3981 let test = parse_expression parser in 1991 3982 expect parser Token.RParen; 1992 1992 - expect_semicolon parser; 3983 3983 + (* Special ASI rule for do-while: semicolon is ALWAYS inserted after ) if not present. 3984 3984 + This doesn't require a newline - the spec says "The previous token is ) and the 3985 3985 + inserted semicolon would then be parsed as the terminating semicolon of a do-while" *) 3986 3986 + if current_token parser = Token.Semicolon then advance parser; 1993 3987 let loc = Source.mk_loc ~start:start_loc.start ~end_:test.Ast.loc.end_ () in 1994 3988 Ast.mk_stmt ~loc (Ast.Do_while { body; test }) 1995 3989 ··· 1999 3993 let discriminant = parse_expression parser in 2000 3994 expect parser Token.RParen; 2001 3995 expect parser Token.LBrace; 3996 3996 + (* Push scope for switch body *) 3997 3997 + push_scope parser ~is_function:false; 2002 3998 let saved_in_switch = parser.in_switch in 2003 3999 parser.in_switch <- true; 2004 4000 let cases = ref [] in 2005 2005 - while current_token parser <> Token.RBrace && not (is_at_end parser) do 2006 2006 - let case_loc = current_loc parser in 2007 2007 - let case_test = 2008 2008 - match current_token parser with 2009 2009 - | Token.Keyword Token.Kw_case -> 2010 2010 - advance parser; 2011 2011 - let e = parse_expression parser in 2012 2012 - expect parser Token.Colon; 2013 2013 - Some e 2014 2014 - | Token.Keyword Token.Kw_default -> 2015 2015 - advance parser; 2016 2016 - expect parser Token.Colon; 2017 2017 - None 2018 2018 - | _ -> error parser (Expected_token ("case or default", current_token parser)) 2019 2019 - in 2020 2020 - let consequent = ref [] in 2021 2021 - while current_token parser <> Token.Keyword Token.Kw_case && 2022 2022 - current_token parser <> Token.Keyword Token.Kw_default && 2023 2023 - current_token parser <> Token.RBrace && 2024 2024 - not (is_at_end parser) do 2025 2025 - consequent := parse_statement parser :: !consequent 2026 2026 - done; 2027 2027 - cases := { Ast.case_test; case_consequent = List.rev !consequent; case_loc } :: !cases 2028 2028 - done; 4001 4001 + let has_default = ref false in 4002 4002 + (try 4003 4003 + while current_token parser <> Token.RBrace && not (is_at_end parser) do 4004 4004 + let case_loc = current_loc parser in 4005 4005 + let case_test = 4006 4006 + match current_token parser with 4007 4007 + | Token.Keyword Token.Kw_case -> 4008 4008 + advance parser; 4009 4009 + let e = parse_expression parser in 4010 4010 + expect parser Token.Colon; 4011 4011 + Some e 4012 4012 + | Token.Keyword Token.Kw_default -> 4013 4013 + if !has_default then 4014 4014 + error parser Duplicate_default; 4015 4015 + has_default := true; 4016 4016 + advance parser; 4017 4017 + expect parser Token.Colon; 4018 4018 + None 4019 4019 + | _ -> error parser (Expected_token ("case or default", current_token parser)) 4020 4020 + in 4021 4021 + let consequent = ref [] in 4022 4022 + (* Per spec: "It is a Syntax Error if UsingDeclaration is contained directly 4023 4023 + within the StatementList of either a CaseClause or a DefaultClause." 4024 4024 + So 'using' is NOT allowed directly here - it must be wrapped in a block { }. *) 4025 4025 + let saved_in_block = parser.in_block in 4026 4026 + parser.in_block <- false; 4027 4027 + (try 4028 4028 + while current_token parser <> Token.Keyword Token.Kw_case && 4029 4029 + current_token parser <> Token.Keyword Token.Kw_default && 4030 4030 + current_token parser <> Token.RBrace && 4031 4031 + not (is_at_end parser) do 4032 4032 + consequent := parse_statement parser :: !consequent 4033 4033 + done 4034 4034 + with e -> 4035 4035 + parser.in_block <- saved_in_block; 4036 4036 + raise e); 4037 4037 + parser.in_block <- saved_in_block; 4038 4038 + cases := { Ast.case_test; case_consequent = List.rev !consequent; case_loc } :: !cases 4039 4039 + done 4040 4040 + with e -> 4041 4041 + pop_scope parser; 4042 4042 + raise e); 4043 4043 + pop_scope parser; 2029 4044 parser.in_switch <- saved_in_switch; 2030 4045 let end_loc = current_loc parser in 2031 4046 expect parser Token.RBrace; ··· 2042 4057 expect parser Token.LParen; 2043 4058 let object_ = parse_expression parser in 2044 4059 expect parser Token.RParen; 2045 2045 - let body = parse_statement parser in 4060 4060 + let body = parse_single_statement parser in 4061 4061 + (* Function/class/let/const/labelled-function declarations not allowed in with body *) 4062 4062 + check_single_statement_body parser body; 2046 4063 let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 2047 4064 Ast.mk_stmt ~loc (Ast.With { object_; body }) 2048 4065 ··· 2051 4068 let label = 2052 4069 if not parser.current.preceded_by_newline then 2053 4070 match current_token parser with 2054 2054 - | Token.Identifier name -> 4071 4071 + | Token.Identifier name | Token.Escaped_identifier name -> 2055 4072 let l = { Ast.name; loc = current_loc parser } in 2056 4073 advance parser; 2057 4074 Some l 2058 4075 | _ -> None 2059 4076 else None 2060 4077 in 2061 2061 - if not parser.in_iteration && not parser.in_switch && label = None then 2062 2062 - error parser Illegal_break; 4078 4078 + (match label with 4079 4079 + | None -> 4080 4080 + if not parser.in_iteration && not parser.in_switch then 4081 4081 + error parser Illegal_break 4082 4082 + | Some l -> 4083 4083 + if not (List.mem l.Ast.name parser.labels) then 4084 4084 + error parser Illegal_break); 2063 4085 expect_semicolon parser; 2064 4086 let loc = Source.mk_loc ~start:start_loc.start ~end_:start_loc.end_ () in 2065 4087 Ast.mk_stmt ~loc (Ast.Break label) ··· 2069 4091 let label = 2070 4092 if not parser.current.preceded_by_newline then 2071 4093 match current_token parser with 2072 2072 - | Token.Identifier name -> 4094 4094 + | Token.Identifier name | Token.Escaped_identifier name -> 2073 4095 let l = { Ast.name; loc = current_loc parser } in 2074 4096 advance parser; 2075 4097 Some l 2076 4098 | _ -> None 2077 4099 else None 2078 4100 in 2079 2079 - if not parser.in_iteration then 2080 2080 - error parser Illegal_continue; 4101 4101 + (match label with 4102 4102 + | None -> 4103 4103 + if not parser.in_iteration then 4104 4104 + error parser Illegal_continue 4105 4105 + | Some l -> 4106 4106 + (* continue with label can only target iteration statements, not arbitrary labeled blocks *) 4107 4107 + if not (List.mem l.Ast.name parser.iteration_labels) then 4108 4108 + error parser Illegal_continue); 2081 4109 expect_semicolon parser; 2082 4110 let loc = Source.mk_loc ~start:start_loc.start ~end_:start_loc.end_ () in 2083 4111 Ast.mk_stmt ~loc (Ast.Continue label) ··· 2119 4147 let is_generator = current_token parser = Token.Star in 2120 4148 if is_generator then advance parser; 2121 4149 let fd_id = parse_identifier parser in 2122 2122 - let fn = parse_function_body parser ~is_generator ~is_async:true in 4150 4150 + (* In strict mode, 'eval' and 'arguments' are not allowed as function names *) 4151 4151 + if parser.strict_mode && (fd_id.name = "eval" || fd_id.name = "arguments") then 4152 4152 + error parser (Strict_eval_arguments fd_id.name); 4153 4153 + (* Add function name to scope for redeclaration detection. 4154 4154 + Async functions (including async generators) are always lexical. *) 4155 4155 + add_binding parser fd_id.name Bind_generator_or_async fd_id.loc; 4156 4156 + let fn = parse_function_body parser ~is_generator ~is_async:true ~fn_name:fd_id () in 2123 4157 let fd_loc = Source.mk_loc ~start:start_loc.start ~end_:fn.fn_body.body_loc.end_ () in 2124 4158 let fd = { 2125 4159 Ast.fd_id; ··· 2141 4175 | Token.Keyword Token.Kw_class -> 2142 4176 (* Class declaration at statement level - NOT treated as expression *) 2143 4177 advance parser; 2144 2144 - let cd_id = parse_identifier parser in 4178 4178 + let cd_id = parse_class_name parser in 4179 4179 + (* Add class name to scope for redeclaration detection *) 4180 4180 + add_binding parser cd_id.name Bind_class cd_id.loc; 4181 4181 + (* Class code is always strict mode *) 4182 4182 + let saved_strict_mode = parser.strict_mode in 4183 4183 + parser.strict_mode <- true; 2145 4184 let cd_super = 2146 4185 if current_token parser = Token.Keyword Token.Kw_extends then begin 2147 4186 advance parser; ··· 2149 4188 end else 2150 4189 None 2151 4190 in 4191 4191 + let saved_in_derived_class = parser.in_derived_class in 4192 4192 + parser.in_derived_class <- cd_super <> None; 2152 4193 let cd_body = parse_class_body parser in 4194 4194 + parser.in_derived_class <- saved_in_derived_class; 4195 4195 + parser.strict_mode <- saved_strict_mode; 2153 4196 let cd_loc = Source.mk_loc ~start:start_loc.start ~end_:cd_body.loc.end_ () in 2154 4197 let cd = { Ast.cd_id; cd_super; cd_body; cd_decorators = []; cd_loc } in 2155 4198 (* No reset_regexp_context needed here - already called in parse_class_body *) ··· 2161 4204 if current_token parser <> Token.Keyword Token.Kw_class then 2162 4205 error parser (Expected_token ("class", current_token parser)); 2163 4206 advance parser; 2164 2164 - let cd_id = parse_identifier parser in 4207 4207 + let cd_id = parse_class_name parser in 4208 4208 + (* Add class name to scope for redeclaration detection *) 4209 4209 + add_binding parser cd_id.name Bind_class cd_id.loc; 4210 4210 + (* Class code is always strict mode *) 4211 4211 + let saved_strict_mode = parser.strict_mode in 4212 4212 + parser.strict_mode <- true; 2165 4213 let cd_super = 2166 4214 if current_token parser = Token.Keyword Token.Kw_extends then begin 2167 4215 advance parser; ··· 2169 4217 end else 2170 4218 None 2171 4219 in 4220 4220 + let saved_in_derived_class = parser.in_derived_class in 4221 4221 + parser.in_derived_class <- cd_super <> None; 2172 4222 let cd_body = parse_class_body parser in 4223 4223 + parser.in_derived_class <- saved_in_derived_class; 4224 4224 + parser.strict_mode <- saved_strict_mode; 2173 4225 let cd_loc = Source.mk_loc ~start:start_loc.start ~end_:cd_body.loc.end_ () in 2174 4226 let cd = { Ast.cd_id; cd_super; cd_body; cd_decorators = decorators; cd_loc } in 2175 4227 Ast.mk_stmt ~loc:cd_loc (Ast.Class cd) 2176 4228 2177 2177 - | Token.Identifier name when (Lexer.peek parser.lexer).tok = Token.Colon -> 4229 4229 + | (Token.Identifier name | Token.Escaped_identifier name) when (Lexer.peek parser.lexer).tok = Token.Colon -> 4230 4230 + (* Check if using reserved word as label *) 4231 4231 + (* Escaped reserved words cannot be used as labels (nul\u006c is not valid) *) 4232 4232 + (match current_token parser with 4233 4233 + | Token.Escaped_identifier esc_name when 4234 4234 + (match esc_name with 4235 4235 + | "null" | "true" | "false" 4236 4236 + | "break" | "case" | "catch" | "continue" | "debugger" | "default" 4237 4237 + | "delete" | "do" | "else" | "finally" | "for" | "function" | "if" 4238 4238 + | "in" | "instanceof" | "new" | "return" | "switch" | "this" | "throw" 4239 4239 + | "try" | "typeof" | "var" | "void" | "while" | "with" 4240 4240 + | "class" | "const" | "enum" | "export" | "extends" | "import" | "super" -> true 4241 4241 + | _ -> false) -> 4242 4242 + error parser (Escaped_keyword esc_name) 4243 4243 + (* Strict mode reserved words when escaped are also not allowed as labels *) 4244 4244 + | Token.Escaped_identifier esc_name when parser.strict_mode && is_strict_reserved_name esc_name -> 4245 4245 + error parser (Escaped_keyword esc_name) 4246 4246 + (* 'yield' when escaped is not allowed as label in generators *) 4247 4247 + | Token.Escaped_identifier "yield" when parser.in_generator -> 4248 4248 + error parser (Escaped_keyword "yield") 4249 4249 + (* 'await' when escaped is not allowed as label in modules/async/static blocks *) 4250 4250 + | Token.Escaped_identifier "await" when parser.in_async || parser.in_module || parser.in_static_block -> 4251 4251 + error parser (Escaped_keyword "await") 4252 4252 + | _ -> ()); 4253 4253 + if name = "yield" && parser.in_generator then 4254 4254 + error parser (Invalid_label_identifier name); 4255 4255 + if name = "await" && (parser.in_async || parser.in_module || parser.in_static_block) then 4256 4256 + error parser (Invalid_label_identifier name); 4257 4257 + if parser.strict_mode && is_strict_reserved_name name then 4258 4258 + error parser (Invalid_label_identifier name); 4259 4259 + advance parser; 4260 4260 + advance parser; 4261 4261 + if List.mem name parser.labels then 4262 4262 + error parser (Duplicate_label name); 4263 4263 + parser.labels <- name :: parser.labels; 4264 4264 + (* Check if the labeled statement body will be an iteration statement. 4265 4265 + Only iteration labels are valid targets for continue. *) 4266 4266 + let is_iteration_ahead = 4267 4267 + let rec check_iteration_lookahead () = 4268 4268 + match current_token parser with 4269 4269 + | Token.Keyword Token.Kw_while | Token.Keyword Token.Kw_do | Token.Keyword Token.Kw_for -> true 4270 4270 + | Token.Identifier _ | Token.Escaped_identifier _ -> 4271 4271 + (* Could be a chained label - check if it's followed by colon *) 4272 4272 + (Lexer.peek parser.lexer).tok = Token.Colon 4273 4273 + | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode -> 4274 4274 + (Lexer.peek parser.lexer).tok = Token.Colon 4275 4275 + | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module && not parser.in_static_block -> 4276 4276 + (Lexer.peek parser.lexer).tok = Token.Colon 4277 4277 + | _ -> false 4278 4278 + in 4279 4279 + check_iteration_lookahead () 4280 4280 + in 4281 4281 + if is_iteration_ahead then 4282 4282 + parser.iteration_labels <- name :: parser.iteration_labels; 4283 4283 + let body = parse_single_statement parser in 4284 4284 + parser.labels <- List.tl parser.labels; 4285 4285 + if is_iteration_ahead then 4286 4286 + parser.iteration_labels <- List.tl parser.iteration_labels; 4287 4287 + (* Check what's allowed as labelled statement body *) 4288 4288 + (match body.Ast.stmt with 4289 4289 + | Ast.Function { fd_async = true; _ } | Ast.Function { fd_generator = true; _ } -> 4290 4290 + (* Async functions and generators not allowed *) 4291 4291 + error parser Function_in_single_statement 4292 4292 + | Ast.Function _ when parser.strict_mode -> 4293 4293 + (* Function declarations not allowed in strict mode *) 4294 4294 + error parser Function_in_single_statement 4295 4295 + | Ast.Class _ | Ast.Variable { var_kind = (Ast.Let | Ast.Const); _ } -> 4296 4296 + (* Class and lexical declarations not allowed *) 4297 4297 + error parser Function_in_single_statement 4298 4298 + | _ -> ()); 4299 4299 + let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 4300 4300 + let label = { Ast.name; loc = start_loc } in 4301 4301 + Ast.mk_stmt ~loc (Ast.Labeled { label; body }) 4302 4302 + 4303 4303 + (* 'yield' as label in non-strict/non-generator code *) 4304 4304 + | Token.Keyword Token.Kw_yield when not parser.in_generator && not parser.strict_mode 4305 4305 + && (Lexer.peek parser.lexer).tok = Token.Colon -> 4306 4306 + let name = "yield" in 2178 4307 advance parser; 2179 4308 advance parser; 2180 4309 if List.mem name parser.labels then 2181 4310 error parser (Duplicate_label name); 2182 4311 parser.labels <- name :: parser.labels; 2183 2183 - let body = parse_statement parser in 4312 4312 + let is_iteration_ahead = 4313 4313 + match current_token parser with 4314 4314 + | Token.Keyword Token.Kw_while | Token.Keyword Token.Kw_do | Token.Keyword Token.Kw_for -> true 4315 4315 + | Token.Identifier _ | Token.Escaped_identifier _ -> 4316 4316 + (Lexer.peek parser.lexer).tok = Token.Colon 4317 4317 + | _ -> false 4318 4318 + in 4319 4319 + if is_iteration_ahead then 4320 4320 + parser.iteration_labels <- name :: parser.iteration_labels; 4321 4321 + let body = parse_single_statement parser in 4322 4322 + parser.labels <- List.tl parser.labels; 4323 4323 + if is_iteration_ahead then 4324 4324 + parser.iteration_labels <- List.tl parser.iteration_labels; 4325 4325 + (match body.Ast.stmt with 4326 4326 + | Ast.Function { fd_async = true; _ } | Ast.Function { fd_generator = true; _ } -> 4327 4327 + error parser Function_in_single_statement 4328 4328 + | Ast.Function _ when parser.strict_mode -> 4329 4329 + error parser Function_in_single_statement 4330 4330 + | Ast.Class _ | Ast.Variable { var_kind = (Ast.Let | Ast.Const); _ } -> 4331 4331 + error parser Function_in_single_statement 4332 4332 + | _ -> ()); 4333 4333 + let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 4334 4334 + let label = { Ast.name; loc = start_loc } in 4335 4335 + Ast.mk_stmt ~loc (Ast.Labeled { label; body }) 4336 4336 + 4337 4337 + (* 'await' as label in non-async/non-module scripts *) 4338 4338 + | Token.Keyword Token.Kw_await when not parser.in_async && not parser.in_module && not parser.in_static_block 4339 4339 + && (Lexer.peek parser.lexer).tok = Token.Colon -> 4340 4340 + let name = "await" in 4341 4341 + advance parser; 4342 4342 + advance parser; 4343 4343 + if List.mem name parser.labels then 4344 4344 + error parser (Duplicate_label name); 4345 4345 + parser.labels <- name :: parser.labels; 4346 4346 + let is_iteration_ahead = 4347 4347 + match current_token parser with 4348 4348 + | Token.Keyword Token.Kw_while | Token.Keyword Token.Kw_do | Token.Keyword Token.Kw_for -> true 4349 4349 + | Token.Identifier _ | Token.Escaped_identifier _ -> 4350 4350 + (Lexer.peek parser.lexer).tok = Token.Colon 4351 4351 + | _ -> false 4352 4352 + in 4353 4353 + if is_iteration_ahead then 4354 4354 + parser.iteration_labels <- name :: parser.iteration_labels; 4355 4355 + let body = parse_single_statement parser in 2184 4356 parser.labels <- List.tl parser.labels; 4357 4357 + if is_iteration_ahead then 4358 4358 + parser.iteration_labels <- List.tl parser.iteration_labels; 4359 4359 + (match body.Ast.stmt with 4360 4360 + | Ast.Function { fd_async = true; _ } | Ast.Function { fd_generator = true; _ } -> 4361 4361 + error parser Function_in_single_statement 4362 4362 + | Ast.Function _ when parser.strict_mode -> 4363 4363 + error parser Function_in_single_statement 4364 4364 + | Ast.Class _ | Ast.Variable { var_kind = (Ast.Let | Ast.Const); _ } -> 4365 4365 + error parser Function_in_single_statement 4366 4366 + | _ -> ()); 2185 4367 let loc = Source.mk_loc ~start:start_loc.start ~end_:body.Ast.loc.end_ () in 2186 4368 let label = { Ast.name; loc = start_loc } in 2187 4369 Ast.mk_stmt ~loc (Ast.Labeled { label; body }) 2188 4370 2189 4371 | _ -> 2190 4372 let expr = parse_expression parser in 4373 4373 + (* Validate expression doesn't contain invalid CoverInitializedName *) 4374 4374 + validate_expression expr; 2191 4375 expect_semicolon parser; 2192 4376 Ast.mk_stmt ~loc:expr.Ast.loc (Ast.Expression expr) 2193 4377 ··· 2208 4392 let specifiers = ref [] in 2209 4393 (* Check for default import *) 2210 4394 (match current_token parser with 2211 2211 - | Token.Identifier name -> 4395 4395 + | Token.Identifier name | Token.Escaped_identifier name -> 2212 4396 let loc = current_loc parser in 4397 4397 + check_strict_binding_identifier parser name; (* modules are always strict *) 2213 4398 advance parser; 2214 4399 specifiers := Ast.Import_default { Ast.name; loc } :: !specifiers; 2215 4400 (* Check for comma (more specifiers follow) *) ··· 2221 4406 advance parser; 2222 4407 expect_keyword parser Token.Kw_as; 2223 4408 let ident = parse_identifier parser in 4409 4409 + check_strict_binding_identifier parser ident.Ast.name; (* modules are always strict *) 2224 4410 specifiers := Ast.Import_namespace ident :: !specifiers 2225 4411 | Token.LBrace -> 2226 4412 advance parser; ··· 2229 4415 match current_token parser with 2230 4416 | Token.String (s, _) -> 2231 4417 let loc = current_loc parser in 4418 4418 + (* Check for unpaired surrogates in string import/export name *) 4419 4419 + if has_unpaired_surrogate s then 4420 4420 + raise (Parse_error (Unpaired_surrogate_in_export_name, loc)); 2232 4421 advance parser; 2233 4422 { Ast.name = s; loc } 2234 4423 | Token.Keyword kw -> ··· 2243 4432 let imported = parse_module_export_name () in 2244 4433 let local = 2245 4434 match current_token parser with 4435 4435 + | Token.Escaped_identifier "as" -> 4436 4436 + (* 'as' keyword must not contain Unicode escapes *) 4437 4437 + error parser (Escaped_contextual_keyword "as") 2246 4438 | Token.Keyword Token.Kw_as | Token.Identifier "as" -> 2247 4439 advance parser; 2248 2248 - parse_identifier parser (* local must be identifier *) 2249 2249 - | _ -> imported 4440 4440 + let id = parse_identifier parser in 4441 4441 + check_strict_binding_identifier parser id.Ast.name; (* modules are always strict *) 4442 4442 + id 4443 4443 + | _ -> 4444 4444 + (* When no 'as', imported name becomes local binding - must be valid *) 4445 4445 + check_strict_binding_identifier parser imported.Ast.name; 4446 4446 + imported 2250 4447 in 2251 4448 specifiers := Ast.Import_named { imported; local } :: !specifiers; 2252 4449 if current_token parser <> Token.RBrace then expect parser Token.Comma ··· 2262 4459 in 2263 4460 skip_import_attributes parser; 2264 4461 expect_semicolon parser; 4462 4462 + (* Check for duplicate bound names in import specifiers *) 4463 4463 + let bound_names = List.filter_map (function 4464 4464 + | Ast.Import_default { Ast.name; _ } -> Some name 4465 4465 + | Ast.Import_namespace { Ast.name; _ } -> Some name 4466 4466 + | Ast.Import_named { local; _ } -> Some local.Ast.name 4467 4467 + ) !specifiers in 4468 4468 + let seen = ref [] in 4469 4469 + List.iter (fun name -> 4470 4470 + if List.mem name !seen then 4471 4471 + error parser (Duplicate_binding name) 4472 4472 + else 4473 4473 + seen := name :: !seen 4474 4474 + ) bound_names; 2265 4475 let end_loc = current_loc parser in 2266 4476 let import_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 2267 4477 Ast.Import { specifiers = List.rev !specifiers; source; import_loc } ··· 2271 4481 | Token.Keyword k when k = kw -> advance parser 2272 4482 | Token.Identifier name when Token.keyword_of_string name = Some kw -> advance parser 2273 4483 | Token.Identifier name when Token.contextual_keyword_of_string name = Some kw -> advance parser 4484 4484 + | Token.Escaped_identifier name when Token.keyword_of_string name = Some kw -> advance parser 4485 4485 + | Token.Escaped_identifier name when Token.contextual_keyword_of_string name = Some kw -> 4486 4486 + (* Contextual keywords must not contain escape sequences *) 4487 4487 + error parser (Escaped_contextual_keyword name) 2274 4488 | tok -> error parser (Expected_token (Token.keyword_to_string kw, tok)) 2275 4489 2276 4490 (** Skip import attributes: with { key: "value", ... } *) 2277 4491 and skip_import_attributes parser = 2278 4492 match current_token parser with 2279 2279 - | Token.Keyword Token.Kw_with | Token.Identifier "with" -> 4493 4493 + | Token.Keyword Token.Kw_with | Token.Identifier "with" | Token.Escaped_identifier "with" -> 2280 4494 advance parser; (* consume 'with' *) 2281 4495 expect parser Token.LBrace; 4496 4496 + let seen_keys = ref [] in 2282 4497 while current_token parser <> Token.RBrace && not (is_at_end parser) do 2283 4498 (* Parse attribute key: IdentifierName (any identifier/keyword) or string *) 2284 2284 - (match current_token parser with 2285 2285 - | Token.String _ | Token.Identifier _ | Token.Keyword _ -> 2286 2286 - advance parser 2287 2287 - | _ -> error parser Expected_identifier); 4499 4499 + let key_loc = current_loc parser in 4500 4500 + let key = match current_token parser with 4501 4501 + | Token.String (s, _) -> 4502 4502 + advance parser; s 4503 4503 + | Token.Identifier s | Token.Escaped_identifier s -> 4504 4504 + advance parser; s 4505 4505 + | Token.Keyword kw -> 4506 4506 + advance parser; Token.keyword_to_string kw 4507 4507 + | _ -> error parser Expected_identifier 4508 4508 + in 4509 4509 + (* Check for duplicate attribute key *) 4510 4510 + if List.mem key !seen_keys then 4511 4511 + raise (Parse_error (Duplicate_attribute_key key, key_loc)); 4512 4512 + seen_keys := key :: !seen_keys; 2288 4513 expect parser Token.Colon; 2289 4514 (* Parse attribute value: must be string *) 2290 4515 (match current_token parser with ··· 2298 4523 2299 4524 and parse_export_declaration parser : Ast.module_declaration = 2300 4525 let start_loc = current_loc parser in 4526 4526 + (* Helper to register all bound names from a variable declaration *) 4527 4527 + let register_export_bound_names (decl : Ast.var_declaration) = 4528 4528 + List.iter (fun (vd : Ast.var_declarator) -> 4529 4529 + List.iter (fun (name, loc) -> 4530 4530 + register_export_name parser name loc 4531 4531 + ) (collect_bound_names_from_pattern vd.var_id) 4532 4532 + ) decl.var_declarations 4533 4533 + in 2301 4534 advance parser; (* consume 'export' *) 2302 4535 match current_token parser with 2303 4536 | Token.Keyword Token.Kw_default -> 2304 4537 (* export default ... *) 4538 4538 + register_export_name parser "default" start_loc; 2305 4539 advance parser; 2306 4540 let declaration = 2307 4541 match current_token parser with ··· 2310 4544 advance parser; 2311 4545 let is_generator = current_token parser = Token.Star in 2312 4546 if is_generator then advance parser; 2313 2313 - let fd_id = 4547 4547 + let (fd_id, has_name) = 2314 4548 match current_token parser with 2315 2315 - | Token.Identifier _ -> parse_identifier parser 2316 2316 - | _ -> { Ast.name = "default"; loc = start_loc } 4549 4549 + | Token.Identifier _ | Token.Escaped_identifier _ -> (parse_identifier parser, true) 4550 4550 + | _ -> ({ Ast.name = "default"; loc = start_loc }, false) 2317 4551 in 2318 2318 - let fn = parse_function_body parser ~is_generator ~is_async:false in 4552 4552 + (* If the function has a name, it becomes a module-level binding. 4553 4553 + Check for duplicate binding before parsing the body. 4554 4554 + Generator functions are lexically scoped like let/const. *) 4555 4555 + if has_name then begin 4556 4556 + let kind = if is_generator then Bind_generator_or_async else Bind_function in 4557 4557 + add_binding parser fd_id.Ast.name kind fd_id.Ast.loc 4558 4558 + end; 4559 4559 + let fn = parse_function_body parser ~is_generator ~is_async:false ~fn_name:fd_id () in 2319 4560 let fd_loc = Source.mk_loc ~start:start.start ~end_:(current_loc parser).end_ () in 2320 4561 Ast.Export_function { fd_id; fd_params = fn.fn_params; fd_body = fn.fn_body; 2321 4562 fd_generator = is_generator; fd_async = false; fd_loc } 2322 4563 | Token.Keyword Token.Kw_class -> 2323 4564 let start = current_loc parser in 2324 4565 advance parser; 2325 2325 - let cd_id = 4566 4566 + let (cd_id, has_name) = 2326 4567 match current_token parser with 2327 2327 - | Token.Identifier _ -> parse_identifier parser 2328 2328 - | _ -> { Ast.name = "default"; loc = start_loc } 4568 4568 + | Token.Identifier _ | Token.Escaped_identifier _ -> (parse_identifier parser, true) 4569 4569 + | _ -> ({ Ast.name = "default"; loc = start_loc }, false) 2329 4570 in 4571 4571 + (* If the class has a name, it becomes a module-level binding. 4572 4572 + Check for duplicate binding before parsing the body. *) 4573 4573 + if has_name then 4574 4574 + add_binding parser cd_id.Ast.name Bind_class cd_id.Ast.loc; 4575 4575 + (* Class code is always strict mode *) 4576 4576 + let saved_strict_mode = parser.strict_mode in 4577 4577 + parser.strict_mode <- true; 2330 4578 let cd_super = 2331 4579 if current_token parser = Token.Keyword Token.Kw_extends then begin 2332 4580 advance parser; 2333 4581 Some (parse_call_expression parser) 2334 4582 end else None 2335 4583 in 4584 4584 + let saved_in_derived_class = parser.in_derived_class in 4585 4585 + parser.in_derived_class <- cd_super <> None; 2336 4586 let cd_body = parse_class_body parser in 4587 4587 + parser.in_derived_class <- saved_in_derived_class; 4588 4588 + parser.strict_mode <- saved_strict_mode; 2337 4589 let cd_loc = Source.mk_loc ~start:start.start ~end_:(current_loc parser).end_ () in 2338 4590 Ast.Export_class { cd_id; cd_super; cd_body; cd_decorators = []; cd_loc } 2339 4591 | Token.Identifier "async" when (Lexer.peek parser.lexer).tok = Token.Keyword Token.Kw_function -> ··· 2342 4594 advance parser; (* function *) 2343 4595 let is_generator = current_token parser = Token.Star in 2344 4596 if is_generator then advance parser; 2345 2345 - let fd_id = 4597 4597 + let (fd_id, has_name) = 2346 4598 match current_token parser with 2347 2347 - | Token.Identifier _ -> parse_identifier parser 2348 2348 - | _ -> { Ast.name = "default"; loc = start_loc } 4599 4599 + | Token.Identifier _ | Token.Escaped_identifier _ -> (parse_identifier parser, true) 4600 4600 + | _ -> ({ Ast.name = "default"; loc = start_loc }, false) 2349 4601 in 2350 2350 - let fn = parse_function_body parser ~is_generator ~is_async:true in 4602 4602 + (* If the function has a name, it becomes a module-level binding. 4603 4603 + Check for duplicate binding before parsing the body. *) 4604 4604 + if has_name then 4605 4605 + add_binding parser fd_id.Ast.name Bind_generator_or_async fd_id.Ast.loc; 4606 4606 + let fn = parse_function_body parser ~is_generator ~is_async:true ~fn_name:fd_id () in 2351 4607 let fd_loc = Source.mk_loc ~start:start.start ~end_:(current_loc parser).end_ () in 2352 4608 Ast.Export_function { fd_id; fd_params = fn.fn_params; fd_body = fn.fn_body; 2353 4609 fd_generator = is_generator; fd_async = true; fd_loc } ··· 2364 4620 advance parser; 2365 4621 let exported = 2366 4622 match current_token parser with 4623 4623 + | Token.Escaped_identifier "as" -> 4624 4624 + (* 'as' keyword must not contain Unicode escapes *) 4625 4625 + error parser (Escaped_contextual_keyword "as") 2367 4626 | Token.Keyword Token.Kw_as | Token.Identifier "as" -> 2368 4627 advance parser; 2369 4628 (* Export name can be any IdentifierName (including keywords) or string *) ··· 2371 4630 match current_token parser with 2372 4631 | Token.String (s, _) -> 2373 4632 let loc = current_loc parser in 4633 4633 + (* Check for unpaired surrogates in string export name *) 4634 4634 + if has_unpaired_surrogate s then 4635 4635 + raise (Parse_error (Unpaired_surrogate_in_export_name, loc)); 2374 4636 advance parser; 2375 4637 { Ast.name = s; loc } 2376 4638 | Token.Keyword kw -> ··· 2380 4642 { Ast.name = name; loc } 2381 4643 | _ -> parse_identifier parser 2382 4644 in 4645 4645 + register_export_name parser ident.Ast.name ident.Ast.loc; 2383 4646 Some ident 2384 2384 - | _ -> None 4647 4647 + | _ -> None (* export * from "mod" exports all names from source, no local registration *) 2385 4648 in 2386 4649 expect_keyword parser Token.Kw_from; 2387 4650 let source = match current_token parser with ··· 2396 4659 | Token.LBrace -> 2397 4660 (* export { ... } or export { ... } from "module" *) 2398 4661 advance parser; 2399 2399 - let specifiers = ref [] in 2400 2400 - (* Helper to parse identifier, keyword, or string literal as module export name *) 4662 4662 + (* Helper to parse identifier, keyword, or string literal as module export name. 4663 4663 + Returns (identifier, is_string_literal). *) 2401 4664 let parse_module_export_name () = 2402 4665 match current_token parser with 2403 4666 | Token.String (s, _) -> 2404 4667 let loc = current_loc parser in 4668 4668 + (* Check for unpaired surrogates in string export name *) 4669 4669 + if has_unpaired_surrogate s then 4670 4670 + raise (Parse_error (Unpaired_surrogate_in_export_name, loc)); 2405 4671 advance parser; 2406 2406 - { Ast.name = s; loc } 4672 4672 + ({ Ast.name = s; loc }, true) 2407 4673 | Token.Keyword kw -> 2408 4674 (* Keywords like 'default' can be used as export names *) 2409 4675 let name = Token.keyword_to_string kw in 2410 4676 let loc = current_loc parser in 2411 4677 advance parser; 2412 2412 - { Ast.name = name; loc } 2413 2413 - | _ -> parse_identifier parser 4678 4678 + ({ Ast.name = name; loc }, false) 4679 4679 + | _ -> (parse_identifier parser, false) 2414 4680 in 4681 4681 + let parsed_specifiers = ref [] in 2415 4682 while current_token parser <> Token.RBrace && not (is_at_end parser) do 2416 2416 - let local = parse_module_export_name () in 2417 2417 - let exported = 4683 4683 + let (local, local_is_string) = parse_module_export_name () in 4684 4684 + let (exported, _) = 2418 4685 match current_token parser with 4686 4686 + | Token.Escaped_identifier "as" -> 4687 4687 + (* 'as' keyword must not contain Unicode escapes *) 4688 4688 + error parser (Escaped_contextual_keyword "as") 2419 4689 | Token.Keyword Token.Kw_as | Token.Identifier "as" -> 2420 4690 advance parser; 2421 4691 parse_module_export_name () 2422 2422 - | _ -> local 4692 4692 + | _ -> (local, local_is_string) 2423 4693 in 2424 2424 - specifiers := { Ast.exported; local } :: !specifiers; 4694 4694 + parsed_specifiers := (local, local_is_string, exported) :: !parsed_specifiers; 2425 4695 if current_token parser <> Token.RBrace then expect parser Token.Comma 2426 4696 done; 2427 4697 expect parser Token.RBrace; 2428 4698 let source = 2429 4699 match current_token parser with 4700 4700 + | Token.Escaped_identifier "from" -> 4701 4701 + (* 'from' keyword must not contain Unicode escapes *) 4702 4702 + error parser (Escaped_contextual_keyword "from") 2430 4703 | Token.Keyword Token.Kw_from | Token.Identifier "from" -> 2431 4704 advance parser; 2432 4705 (match current_token parser with ··· 2437 4710 | _ -> error parser (Expected_token ("string", current_token parser))) 2438 4711 | _ -> None 2439 4712 in 4713 4713 + (* Register exported names - only for direct exports, not re-exports with from. 4714 4714 + Also validate that string literals are not used as local binding in direct exports. 4715 4715 + Track local bindings for validation at end of module. *) 4716 4716 + let specifiers = List.rev_map (fun ((local_ident : Ast.identifier), local_is_string, (exported_ident : Ast.identifier)) -> 4717 4717 + if source = None then begin 4718 4718 + (* Direct export - local must refer to a binding, so string literals are not allowed *) 4719 4719 + if local_is_string then 4720 4720 + raise (Parse_error (String_local_export_binding, local_ident.Ast.loc)); 4721 4721 + register_export_name parser exported_ident.Ast.name exported_ident.Ast.loc; 4722 4722 + (* Record local name for validation that it's a declared module binding *) 4723 4723 + parser.pending_export_bindings <- (local_ident.Ast.name, local_ident.Ast.loc) :: parser.pending_export_bindings 4724 4724 + end; 4725 4725 + { Ast.exported = exported_ident; local = local_ident } 4726 4726 + ) !parsed_specifiers in 2440 4727 expect_semicolon parser; 2441 4728 let end_loc = current_loc parser in 2442 4729 let export_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 2443 2443 - Ast.Export_named { specifiers = List.rev !specifiers; source; declaration = None; export_loc } 4730 4730 + Ast.Export_named { specifiers; source; declaration = None; export_loc } 2444 4731 | Token.Keyword Token.Kw_var -> 2445 4732 (* export var ... *) 2446 4733 advance parser; 2447 4734 let decl = parse_variable_declaration parser Ast.Var in 4735 4735 + register_export_bound_names decl; 2448 4736 expect_semicolon parser; 2449 4737 let end_loc = current_loc parser in 2450 4738 let export_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in ··· 2455 4743 (* export let ... *) 2456 4744 advance parser; 2457 4745 let decl = parse_variable_declaration parser Ast.Let in 4746 4746 + register_export_bound_names decl; 2458 4747 expect_semicolon parser; 2459 4748 let end_loc = current_loc parser in 2460 4749 let export_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in ··· 2465 4754 (* export const ... *) 2466 4755 advance parser; 2467 4756 let decl = parse_variable_declaration parser Ast.Const in 4757 4757 + check_const_initializers parser decl; 4758 4758 + register_export_bound_names decl; 2468 4759 expect_semicolon parser; 2469 4760 let end_loc = current_loc parser in 2470 4761 let export_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in ··· 2478 4769 let is_generator = current_token parser = Token.Star in 2479 4770 if is_generator then advance parser; 2480 4771 let fd_id = parse_identifier parser in 2481 2481 - let fn = parse_function_body parser ~is_generator ~is_async:false in 4772 4772 + register_export_name parser fd_id.Ast.name fd_id.Ast.loc; 4773 4773 + let fn = parse_function_body parser ~is_generator ~is_async:false ~fn_name:fd_id () in 2482 4774 let fd_loc = Source.mk_loc ~start:start.start ~end_:(current_loc parser).end_ () in 2483 4775 let fd = { Ast.fd_id; fd_params = fn.fn_params; fd_body = fn.fn_body; 2484 4776 fd_generator = is_generator; fd_async = false; fd_loc } in ··· 2490 4782 (* export class ... *) 2491 4783 let start = current_loc parser in 2492 4784 advance parser; 2493 2493 - let cd_id = parse_identifier parser in 4785 4785 + let cd_id = parse_class_name parser in 4786 4786 + register_export_name parser cd_id.Ast.name cd_id.Ast.loc; 4787 4787 + (* Class code is always strict mode *) 4788 4788 + let saved_strict_mode = parser.strict_mode in 4789 4789 + parser.strict_mode <- true; 2494 4790 let cd_super = 2495 4791 if current_token parser = Token.Keyword Token.Kw_extends then begin 2496 4792 advance parser; 2497 4793 Some (parse_call_expression parser) 2498 4794 end else None 2499 4795 in 4796 4796 + let saved_in_derived_class = parser.in_derived_class in 4797 4797 + parser.in_derived_class <- cd_super <> None; 2500 4798 let cd_body = parse_class_body parser in 4799 4799 + parser.in_derived_class <- saved_in_derived_class; 4800 4800 + parser.strict_mode <- saved_strict_mode; 2501 4801 let cd_loc = Source.mk_loc ~start:start.start ~end_:(current_loc parser).end_ () in 2502 4802 let cd = { Ast.cd_id; cd_super; cd_body; cd_decorators = []; cd_loc } in 2503 4803 let export_loc = Source.mk_loc ~start:start_loc.start ~end_:cd_loc.end_ () in ··· 2512 4812 let is_generator = current_token parser = Token.Star in 2513 4813 if is_generator then advance parser; 2514 4814 let fd_id = parse_identifier parser in 2515 2515 - let fn = parse_function_body parser ~is_generator ~is_async:true in 4815 4815 + register_export_name parser fd_id.Ast.name fd_id.Ast.loc; 4816 4816 + let fn = parse_function_body parser ~is_generator ~is_async:true ~fn_name:fd_id () in 2516 4817 let fd_loc = Source.mk_loc ~start:start.start ~end_:(current_loc parser).end_ () in 2517 4818 let fd = { Ast.fd_id; fd_params = fn.fn_params; fd_body = fn.fn_body; 2518 4819 fd_generator = is_generator; fd_async = true; fd_loc } in ··· 2545 4846 parsing_directives := false; 2546 4847 Ast.Stmt s 2547 4848 end else begin 4849 4849 + (* Import declaration only allowed in modules *) 4850 4850 + if not is_module then 4851 4851 + error parser Import_export_in_script; 2548 4852 detected_module := true; 2549 4853 parser.strict_mode <- true; (* Modules are always strict mode *) 2550 4854 parser.in_module <- true; ··· 2552 4856 Ast.Module_decl (parse_import_declaration parser) 2553 4857 end 2554 4858 | Token.Keyword Token.Kw_export -> 4859 4859 + (* Export declaration only allowed in modules *) 4860 4860 + if not is_module then 4861 4861 + error parser Import_export_in_script; 2555 4862 detected_module := true; 2556 4863 parser.strict_mode <- true; (* Modules are always strict mode *) 2557 4864 parser.in_module <- true; ··· 2570 4877 in 2571 4878 items := item :: !items 2572 4879 done; 4880 4880 + (* Validate exported bindings for modules. 4881 4881 + All local names in `export { x }` must be declared at module level. *) 4882 4882 + if !detected_module then begin 4883 4883 + let module_scope = List.hd (List.rev parser.scopes) in 4884 4884 + List.iter (fun (name, loc) -> 4885 4885 + if not (Hashtbl.mem module_scope.scope_bindings name) then 4886 4886 + raise (Parse_error (Undeclared_export name, loc)) 4887 4887 + ) parser.pending_export_bindings 4888 4888 + end; 2573 4889 let end_loc = current_loc parser in 2574 4890 let program_loc = Source.mk_loc ~start:start_loc.start ~end_:end_loc.end_ () in 2575 4891 { ··· 2594 4910 | Strict_mode_with -> Format.fprintf fmt "'with' statement not allowed in strict mode" 2595 4911 | Strict_mode_octal -> Format.fprintf fmt "Octal literals not allowed in strict mode" 2596 4912 | Invalid_destructuring -> Format.fprintf fmt "Invalid destructuring pattern" 4913 4913 + | Duplicate_parameter s -> Format.fprintf fmt "Duplicate parameter name: %s" s 4914 4914 + | Rest_parameter_last -> Format.fprintf fmt "Rest parameter must be last formal parameter" 4915 4915 + | Strict_reserved_word s -> Format.fprintf fmt "Unexpected strict mode reserved word: %s" s 4916 4916 + | Strict_eval_arguments s -> Format.fprintf fmt "'%s' not allowed in strict mode" s 4917 4917 + | Use_strict_non_simple_params -> Format.fprintf fmt "'use strict' not allowed in function with non-simple parameters" 4918 4918 + | Private_static_getter_setter_mismatch -> Format.fprintf fmt "Private static getter and setter must both be static or non-static" 4919 4919 + | Invalid_class_name s -> Format.fprintf fmt "Invalid class name: %s" s 4920 4920 + | Invalid_binding_identifier s -> Format.fprintf fmt "Invalid binding identifier: %s" s 4921 4921 + | Invalid_label_identifier s -> Format.fprintf fmt "Invalid label identifier: %s" s 4922 4922 + | Escaped_keyword s -> Format.fprintf fmt "Keyword must not contain escaped characters: %s" s 4923 4923 + | Await_in_parameter -> Format.fprintf fmt "'await' expression not allowed in parameter" 4924 4924 + | Yield_in_parameter -> Format.fprintf fmt "'yield' expression not allowed in parameter" 4925 4925 + | Illegal_newline_after_throw -> Format.fprintf fmt "Illegal newline after throw" 4926 4926 + | Let_in_lexical_binding -> Format.fprintf fmt "'let' is not allowed as a lexically bound name" 4927 4927 + | Duplicate_default -> Format.fprintf fmt "More than one default clause in switch statement" 4928 4928 + | Const_no_initializer -> Format.fprintf fmt "Missing initializer in const declaration" 4929 4929 + | For_in_of_const_no_init -> Format.fprintf fmt "for-in/of loop variable declaration may not have an initializer" 4930 4930 + | Invalid_lhs_in_for -> Format.fprintf fmt "Invalid left-hand side in for-in/of loop" 4931 4931 + | Invalid_regex_flag s -> Format.fprintf fmt "Invalid regular expression flag: %s" s 4932 4932 + | Duplicate_regex_flag c -> Format.fprintf fmt "Duplicate regular expression flag: %c" c 4933 4933 + | Invalid_regex_pattern s -> Format.fprintf fmt "Invalid regular expression: %s" s 4934 4934 + | Getter_with_parameters -> Format.fprintf fmt "Getter must not have any formal parameters" 4935 4935 + | Setter_wrong_param_count -> Format.fprintf fmt "Setter must have exactly one formal parameter" 4936 4936 + | Super_call_outside_constructor -> Format.fprintf fmt "super() call is only valid in a constructor" 4937 4937 + | Escaped_contextual_keyword s -> Format.fprintf fmt "Contextual keyword must not contain escaped characters: %s" s 4938 4938 + | Static_prototype_method -> Format.fprintf fmt "Static class element cannot be named 'prototype'" 4939 4939 + | Private_constructor -> Format.fprintf fmt "Private class element cannot be named '#constructor'" 4940 4940 + | Cannot_use_new_with_import -> Format.fprintf fmt "Cannot use 'new' with 'import()'" 4941 4941 + | Constructor_field -> Format.fprintf fmt "Class fields cannot be named 'constructor'" 4942 4942 + | Arguments_in_class_field -> Format.fprintf fmt "'arguments' is not allowed in class field initializer" 4943 4943 + | Super_in_class_field -> Format.fprintf fmt "'super' is not allowed in class field initializer" 4944 4944 + | New_target_outside_function -> Format.fprintf fmt "'new.target' expression is not allowed here" 4945 4945 + | Super_outside_method -> Format.fprintf fmt "'super' keyword is not allowed here" 4946 4946 + | Super_private_access -> Format.fprintf fmt "Private name cannot be accessed on 'super'" 4947 4947 + | Import_export_in_script -> Format.fprintf fmt "'import' and 'export' may only appear with 'sourceType: module'" 4948 4948 + | Using_in_for_in -> Format.fprintf fmt "'using' declaration is not allowed in for-in loop" 4949 4949 + | Using_at_script_top_level -> Format.fprintf fmt "'using' declaration is not allowed at the top level of a script" 4950 4950 + | Using_destructuring_pattern -> Format.fprintf fmt "'using' and 'await using' only allow simple identifier bindings, not destructuring patterns" 4951 4951 + | Using_not_in_block -> Format.fprintf fmt "'using' declaration is only allowed in a block statement" 4952 4952 + | Function_in_single_statement -> Format.fprintf fmt "Function declaration not allowed as single statement" 4953 4953 + | Multiple_bindings_in_for -> Format.fprintf fmt "Only one declaration allowed in for-in/for-of loop" 4954 4954 + | Duplicate_private_name s -> Format.fprintf fmt "Duplicate private name: #%s" s 4955 4955 + | Undeclared_private_name s -> Format.fprintf fmt "Undeclared private name: #%s" s 4956 4956 + | Duplicate_binding s -> Format.fprintf fmt "Duplicate binding: %s" s 4957 4957 + | Special_constructor -> Format.fprintf fmt "Special method 'constructor' cannot be a getter, setter, generator, or async" 4958 4958 + | Duplicate_constructor -> Format.fprintf fmt "A class may only have one constructor" 4959 4959 + | Duplicate_export s -> Format.fprintf fmt "Duplicate export: %s" s 4960 4960 + | Invalid_shorthand_initializer -> Format.fprintf fmt "Invalid shorthand property initializer" 4961 4961 + | Duplicate_proto -> Format.fprintf fmt "Duplicate __proto__ property" 4962 4962 + | Nullish_mixing_logical -> Format.fprintf fmt "Nullish coalescing operator (??) requires parentheses when used alongside logical operators (|| or &&)" 4963 4963 + | Invalid_template_escape -> Format.fprintf fmt "Invalid escape sequence in untagged template literal" 4964 4964 + | Unpaired_surrogate_in_export_name -> Format.fprintf fmt "Export name contains unpaired surrogate" 4965 4965 + | String_local_export_binding -> Format.fprintf fmt "Cannot use string as local binding in export" 4966 4966 + | Undeclared_export s -> Format.fprintf fmt "Export '%s' is not defined" s 4967 4967 + | Duplicate_attribute_key s -> Format.fprintf fmt "Duplicate attribute key: %s" s 4968 4968 + | Default_export_binding_exists s -> Format.fprintf fmt "Identifier '%s' has already been declared" s 2597 4969 2598 4970 let show_error err = Format.asprintf "%a" pp_error err

+92 -19

lib/quickjs/parser/parser.mli

reviewed

··· 1 1 (** JavaScript Parser. 2 2 3 3 - A recursive-descent parser for ECMAScript 2024. *) 3 3 + A recursive-descent parser for ECMAScript 2024 that produces an abstract 4 4 + syntax tree from a token stream. Implements full ES2024 grammar including 5 5 + classes, async/await, generators, decorators, and explicit resource 6 6 + management (using declarations). *) 4 7 5 5 - (** Parse errors *) 8 8 + (** {1 Error Types} *) 9 9 + 10 10 + (** Parse errors with semantic information about what went wrong. *) 6 11 type error = 7 7 - | Unexpected_token of Token.t 8 8 - | Expected_token of string * Token.t 9 9 - | Expected_identifier 10 10 - | Expected_expression 11 11 - | Expected_statement 12 12 - | Invalid_assignment_target 13 13 - | Duplicate_label of string 14 14 - | Illegal_break 15 15 - | Illegal_continue 16 16 - | Illegal_return 17 17 - | Strict_mode_with 18 18 - | Strict_mode_octal 19 19 - | Invalid_destructuring 12 12 + | Unexpected_token of Token.t (** Unexpected token encountered *) 13 13 + | Expected_token of string * Token.t (** Expected one token, got another *) 14 14 + | Expected_identifier (** Expected an identifier *) 15 15 + | Expected_expression (** Expected an expression *) 16 16 + | Expected_statement (** Expected a statement *) 17 17 + | Invalid_assignment_target (** Left-hand side is not assignable *) 18 18 + | Duplicate_label of string (** Label already defined in scope *) 19 19 + | Illegal_break (** Break outside loop/switch *) 20 20 + | Illegal_continue (** Continue outside loop *) 21 21 + | Illegal_return (** Return outside function *) 22 22 + | Strict_mode_with (** 'with' not allowed in strict mode *) 23 23 + | Strict_mode_octal (** Octal literal in strict mode *) 24 24 + | Invalid_destructuring (** Invalid destructuring pattern *) 25 25 + | Duplicate_parameter of string (** Duplicate parameter name *) 26 26 + | Rest_parameter_last (** Rest parameter must be last *) 27 27 + | Strict_reserved_word of string (** Reserved word used as identifier *) 28 28 + | Strict_eval_arguments of string (** eval/arguments as binding in strict mode *) 29 29 + | Use_strict_non_simple_params (** "use strict" with non-simple params *) 30 30 + | Private_static_getter_setter_mismatch (** Static getter/setter mismatch *) 31 31 + | Invalid_class_name of string (** Invalid class name *) 32 32 + | Invalid_binding_identifier of string (** Invalid binding identifier *) 33 33 + | Invalid_label_identifier of string (** Invalid label name *) 34 34 + | Escaped_keyword of string (** Escaped keyword not allowed *) 35 35 + | Await_in_parameter (** Await in parameter default *) 36 36 + | Yield_in_parameter (** Yield in parameter default *) 37 37 + | Illegal_newline_after_throw (** Newline after throw keyword *) 38 38 + | Let_in_lexical_binding (** 'let' as lexical binding name *) 39 39 + | Duplicate_default (** Multiple default clauses in switch *) 40 40 + | Const_no_initializer (** Const declaration without initializer *) 41 41 + | For_in_of_const_no_init (** For-in/of with const but no init allowed *) 42 42 + | Invalid_lhs_in_for (** Invalid left-hand side in for loop *) 43 43 + | Invalid_regex_flag of string (** Invalid regular expression flag *) 44 44 + | Duplicate_regex_flag of char (** Duplicate flag in regex *) 45 45 + | Invalid_regex_pattern of string (** Invalid regex pattern *) 46 46 + | Getter_with_parameters (** Getter defined with parameters *) 47 47 + | Setter_wrong_param_count (** Setter must have exactly one param *) 48 48 + | Super_call_outside_constructor (** super() outside constructor *) 49 49 + | Escaped_contextual_keyword of string (** Escaped contextual keyword *) 50 50 + | Static_prototype_method (** Static method named 'prototype' *) 51 51 + | Private_constructor (** Private constructor not allowed *) 52 52 + | Cannot_use_new_with_import (** new import() is not allowed *) 53 53 + | Constructor_field (** Field named 'constructor' *) 54 54 + | Arguments_in_class_field (** 'arguments' in class field initializer *) 55 55 + | Super_in_class_field (** 'super' in class field context *) 56 56 + | New_target_outside_function (** new.target outside function *) 57 57 + | Super_outside_method (** super outside method *) 58 58 + | Super_private_access (** super with private field access *) 59 59 + | Import_export_in_script (** import/export in non-module script *) 60 60 + | Using_in_for_in (** 'using' in for-in loop *) 61 61 + | Using_at_script_top_level (** 'using' at script top level *) 62 62 + | Using_destructuring_pattern (** 'using' with destructuring *) 63 63 + | Using_not_in_block (** 'using' outside block scope *) 64 64 + | Function_in_single_statement (** Function decl as single statement *) 65 65 + | Multiple_bindings_in_for (** Multiple bindings in for-in/of *) 66 66 + | Duplicate_private_name of string (** Duplicate private field name *) 67 67 + | Undeclared_private_name of string (** Private field not declared *) 68 68 + | Duplicate_binding of string (** Duplicate variable binding *) 69 69 + | Special_constructor (** Constructor is generator/async *) 70 70 + | Duplicate_constructor (** Multiple constructors in class *) 71 71 + | Duplicate_export of string (** Export name already used *) 72 72 + | Invalid_shorthand_initializer (** Invalid shorthand property init *) 73 73 + | Duplicate_proto (** Duplicate __proto__ in literal *) 74 74 + | Nullish_mixing_logical (** ?? mixed with && or || *) 75 75 + | Invalid_template_escape (** Invalid escape in untagged template *) 76 76 + | Unpaired_surrogate_in_export_name (** Unpaired surrogate in string export *) 77 77 + | String_local_export_binding (** String as local binding in export *) 78 78 + | Undeclared_export of string (** Exported name not declared *) 79 79 + | Duplicate_attribute_key of string (** Duplicate import attribute key *) 80 80 + | Default_export_binding_exists of string (** Default export conflicts *) 20 81 82 82 + (** Exception raised when a parse error occurs. *) 21 83 exception Parse_error of error * Source.loc 22 84 23 23 - (** Parser state *) 85 85 + (** {1 Parser Type} *) 86 86 + 87 87 + (** The parser state. Opaque type that tracks parsing context and scope. *) 24 88 type t 25 89 26 26 - (** Create a parser from a lexer *) 90 90 + (** {1 Construction and Parsing} *) 91 91 + 92 92 + (** [create lexer] creates a new parser from the given lexer. *) 27 93 val create : Lexer.t -> t 28 94 29 29 - (** Parse a complete program. Use ~is_module:true for ES modules. *) 95 95 + (** [parse_program ?is_module parser] parses a complete JavaScript program. 96 96 + @param is_module If [true], parse as ES module (default: [false]) 97 97 + @return The parsed program AST 98 98 + @raise Parse_error on syntax errors *) 30 99 val parse_program : ?is_module:bool -> t -> Ast.program 31 100 32 32 - (** Error formatting *) 101 101 + (** {1 Error Formatting} *) 102 102 + 103 103 + (** [pp_error fmt err] pretty-prints a parse error. *) 33 104 val pp_error : Format.formatter -> error -> unit 105 105 + 106 106 + (** [show_error err] returns a string representation of the error. *) 34 107 val show_error : error -> string

+944

lib/quickjs/parser/regexp_validator.ml

reviewed

··· 1 1 + (** RegExp pattern validator for ECMAScript. 2 2 + 3 3 + This module validates regular expression patterns and flags according 4 4 + to the ECMAScript specification, detecting early syntax errors. *) 5 5 + 6 6 + type error = 7 7 + | Duplicate_flag of char 8 8 + | Invalid_flag of char 9 9 + | Incompatible_flags of char * char 10 10 + | Nothing_to_repeat 11 11 + | Invalid_quantifier_range 12 12 + | Unterminated_group 13 13 + | Unterminated_character_class 14 14 + | Invalid_group 15 15 + | Invalid_escape of string 16 16 + | Invalid_unicode_escape 17 17 + | Invalid_hex_escape 18 18 + | Invalid_control_escape 19 19 + | Invalid_class_range 20 20 + | Lone_quantifier_brackets 21 21 + | Invalid_named_capture_group 22 22 + | Duplicate_capture_group_name of string 23 23 + | Invalid_backreference 24 24 + | Unmatched_paren 25 25 + | Line_terminator_in_pattern 26 26 + | Invalid_unicode_property of string 27 27 + 28 28 + exception Regexp_error of error 29 29 + 30 30 + let pp_error fmt = function 31 31 + | Duplicate_flag c -> Format.fprintf fmt "Duplicate regular expression flag '%c'" c 32 32 + | Invalid_flag c -> Format.fprintf fmt "Invalid regular expression flag '%c'" c 33 33 + | Incompatible_flags (a, b) -> Format.fprintf fmt "Incompatible regular expression flags '%c' and '%c'" a b 34 34 + | Nothing_to_repeat -> Format.fprintf fmt "Nothing to repeat" 35 35 + | Invalid_quantifier_range -> Format.fprintf fmt "Invalid quantifier range" 36 36 + | Unterminated_group -> Format.fprintf fmt "Unterminated group" 37 37 + | Unterminated_character_class -> Format.fprintf fmt "Unterminated character class" 38 38 + | Invalid_group -> Format.fprintf fmt "Invalid group" 39 39 + | Invalid_escape s -> Format.fprintf fmt "Invalid escape sequence: %s" s 40 40 + | Invalid_unicode_escape -> Format.fprintf fmt "Invalid Unicode escape sequence" 41 41 + | Invalid_hex_escape -> Format.fprintf fmt "Invalid hexadecimal escape sequence" 42 42 + | Invalid_control_escape -> Format.fprintf fmt "Invalid control escape sequence" 43 43 + | Invalid_class_range -> Format.fprintf fmt "Invalid character class range" 44 44 + | Lone_quantifier_brackets -> Format.fprintf fmt "Lone quantifier brackets" 45 45 + | Invalid_named_capture_group -> Format.fprintf fmt "Invalid named capture group" 46 46 + | Duplicate_capture_group_name s -> Format.fprintf fmt "Duplicate capture group name: %s" s 47 47 + | Invalid_backreference -> Format.fprintf fmt "Invalid backreference" 48 48 + | Unmatched_paren -> Format.fprintf fmt "Unmatched ')'" 49 49 + | Line_terminator_in_pattern -> Format.fprintf fmt "Invalid line terminator in pattern" 50 50 + | Invalid_unicode_property s -> Format.fprintf fmt "Invalid Unicode property: %s" s 51 51 + 52 52 + let show_error e = Format.asprintf "%a" pp_error e 53 53 + 54 54 + (* Regexp flags *) 55 55 + type flags = { 56 56 + global : bool; 57 57 + ignore_case : bool; 58 58 + multiline : bool; 59 59 + dotall : bool; 60 60 + unicode : bool; 61 61 + unicode_sets : bool; 62 62 + sticky : bool; 63 63 + has_indices : bool; 64 64 + } 65 65 + 66 66 + let empty_flags = { 67 67 + global = false; 68 68 + ignore_case = false; 69 69 + multiline = false; 70 70 + dotall = false; 71 71 + unicode = false; 72 72 + unicode_sets = false; 73 73 + sticky = false; 74 74 + has_indices = false; 75 75 + } 76 76 + 77 77 + let validate_flags flags_str = 78 78 + let seen = Hashtbl.create 8 in 79 79 + let flags = ref empty_flags in 80 80 + String.iter (fun c -> 81 81 + if Hashtbl.mem seen c then 82 82 + raise (Regexp_error (Duplicate_flag c)); 83 83 + Hashtbl.add seen c true; 84 84 + match c with 85 85 + | 'g' -> flags := { !flags with global = true } 86 86 + | 'i' -> flags := { !flags with ignore_case = true } 87 87 + | 'm' -> flags := { !flags with multiline = true } 88 88 + | 's' -> flags := { !flags with dotall = true } 89 89 + | 'u' -> flags := { !flags with unicode = true } 90 90 + | 'v' -> flags := { !flags with unicode_sets = true } 91 91 + | 'y' -> flags := { !flags with sticky = true } 92 92 + | 'd' -> flags := { !flags with has_indices = true } 93 93 + | _ -> raise (Regexp_error (Invalid_flag c)) 94 94 + ) flags_str; 95 95 + (* u and v flags are mutually exclusive *) 96 96 + if !flags.unicode && !flags.unicode_sets then 97 97 + raise (Regexp_error (Incompatible_flags ('u', 'v'))); 98 98 + !flags 99 99 + 100 100 + (* Pattern validator state *) 101 101 + type state = { 102 102 + pattern : string; 103 103 + mutable pos : int; 104 104 + flags : flags; 105 105 + mutable capture_count : int; 106 106 + mutable named_groups : string list; (* All group names (for backreference validation) *) 107 107 + mutable named_groups_with_scope : (string * int) list; (* Group names with their scope for duplicate detection *) 108 108 + mutable named_backreferences : string list; 109 109 + mutable max_backreference : int; 110 110 + mutable has_invalid_k_escape : bool; (* True if we saw \k without proper syntax *) 111 111 + mutable group_name_scope : int; (* Current scope for group names (incremented at |) *) 112 112 + } 113 113 + 114 114 + let is_at_end s = s.pos >= String.length s.pattern 115 115 + 116 116 + let peek s = 117 117 + if is_at_end s then None 118 118 + else Some s.pattern.[s.pos] 119 119 + 120 120 + let peek_n s n = 121 121 + if s.pos + n > String.length s.pattern then None 122 122 + else Some (String.sub s.pattern s.pos n) 123 123 + 124 124 + let advance s = 125 125 + if not (is_at_end s) then s.pos <- s.pos + 1 126 126 + 127 127 + let consume s = 128 128 + if is_at_end s then None 129 129 + else begin 130 130 + let c = s.pattern.[s.pos] in 131 131 + s.pos <- s.pos + 1; 132 132 + Some c 133 133 + end 134 134 + 135 135 + let expect s c = 136 136 + match peek s with 137 137 + | Some c' when c' = c -> advance s; true 138 138 + | _ -> false 139 139 + 140 140 + let is_unicode_mode s = s.flags.unicode || s.flags.unicode_sets 141 141 + 142 142 + let is_digit c = c >= '0' && c <= '9' 143 143 + let is_hex_digit c = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') 144 144 + let is_octal_digit c = c >= '0' && c <= '7' 145 145 + 146 146 + (* Check if character is a line terminator *) 147 147 + let is_line_terminator c = 148 148 + c = '\n' || c = '\r' 149 149 + 150 150 + (* Check if next bytes are a Unicode line terminator (U+2028 or U+2029) *) 151 151 + let is_unicode_line_terminator s = 152 152 + match peek_n s 3 with 153 153 + | Some str when String.length str = 3 -> 154 154 + (* U+2028 Line Separator: E2 80 A8 *) 155 155 + (* U+2029 Paragraph Separator: E2 80 A9 *) 156 156 + (Char.code str.[0] = 0xE2 && Char.code str.[1] = 0x80 && 157 157 + (Char.code str.[2] = 0xA8 || Char.code str.[2] = 0xA9)) 158 158 + | _ -> false 159 159 + 160 160 + (* Check if character is a SyntaxCharacter *) 161 161 + let is_syntax_char c = 162 162 + c = '^' || c = '$' || c = '\\' || c = '.' || c = '*' || c = '+' || 163 163 + c = '?' || c = '(' || c = ')' || c = '[' || c = ']' || c = '{' || 164 164 + c = '}' || c = '|' 165 165 + 166 166 + (* Parse a decimal number *) 167 167 + let parse_decimal s = 168 168 + let start = s.pos in 169 169 + while not (is_at_end s) && is_digit (Option.get (peek s)) do 170 170 + advance s 171 171 + done; 172 172 + if s.pos > start then 173 173 + Some (int_of_string (String.sub s.pattern start (s.pos - start))) 174 174 + else 175 175 + None 176 176 + 177 177 + (* Validate escape sequence in pattern *) 178 178 + let rec validate_escape s ~in_class ?(in_negated_class=false) () = 179 179 + match consume s with 180 180 + | None -> raise (Regexp_error (Invalid_escape "\\")) 181 181 + | Some c -> 182 182 + match c with 183 183 + (* Identity escapes for syntax characters *) 184 184 + | '^' | '$' | '\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '/' -> () 185 185 + (* Character class escapes *) 186 186 + | 'd' | 'D' | 's' | 'S' | 'w' | 'W' -> () 187 187 + (* Assertions *) 188 188 + | 'b' | 'B' when not in_class -> () 189 189 + (* Control escapes *) 190 190 + | 'f' | 'n' | 'r' | 't' | 'v' -> () 191 191 + | 'b' when in_class -> () (* \b in character class is backspace *) 192 192 + (* Control letter escape *) 193 193 + | 'c' -> 194 194 + (match peek s with 195 195 + | Some c when (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') -> advance s 196 196 + | _ when is_unicode_mode s -> raise (Regexp_error Invalid_control_escape) 197 197 + | _ -> ()) (* In non-unicode mode, \c followed by invalid char is allowed (Annex B) *) 198 198 + (* Hex escape *) 199 199 + | 'x' -> 200 200 + (match peek_n s 2 with 201 201 + | Some hh when is_hex_digit hh.[0] && is_hex_digit hh.[1] -> 202 202 + advance s; advance s 203 203 + | _ when is_unicode_mode s -> raise (Regexp_error Invalid_hex_escape) 204 204 + | _ -> ()) (* Annex B: \x followed by non-hex is literal 'x' *) 205 205 + (* Unicode escape *) 206 206 + | 'u' -> 207 207 + validate_unicode_escape s 208 208 + (* Octal escape - only in non-unicode mode for non-classes *) 209 209 + | '0' -> 210 210 + (* \0 is NUL. \0 followed by another octal digit is legacy octal *) 211 211 + (match peek s with 212 212 + | Some c when is_octal_digit c -> 213 213 + if is_unicode_mode s then 214 214 + raise (Regexp_error (Invalid_escape "legacy octal")) 215 215 + else begin 216 216 + (* Parse legacy octal *) 217 217 + advance s; 218 218 + if Option.map is_octal_digit (peek s) = Some true then advance s 219 219 + end 220 220 + | _ -> ()) 221 221 + | '1'..'9' as c -> 222 222 + (* Could be a backreference or legacy octal escape *) 223 223 + s.pos <- s.pos - 1; (* Put back the digit *) 224 224 + let start = s.pos in 225 225 + let n = parse_decimal s in 226 226 + (match n with 227 227 + | Some num -> 228 228 + if num <= s.capture_count then 229 229 + (* Valid backreference *) 230 230 + s.max_backreference <- max s.max_backreference num 231 231 + else if is_unicode_mode s then 232 232 + raise (Regexp_error Invalid_backreference) 233 233 + else begin 234 234 + (* In non-unicode mode, could be legacy octal or escaped digit *) 235 235 + s.pos <- start; 236 236 + if is_octal_digit c then begin 237 237 + advance s; (* First digit *) 238 238 + if Option.map is_octal_digit (peek s) = Some true then advance s; 239 239 + if Option.map is_octal_digit (peek s) = Some true then advance s 240 240 + end else 241 241 + advance s (* Just the single digit *) 242 242 + end 243 243 + | None -> ()) 244 244 + (* Unicode property escapes *) 245 245 + | 'p' | 'P' as c -> 246 246 + if is_unicode_mode s then 247 247 + validate_unicode_property_escape s ~negated:(c = 'P') ~in_negated_class 248 248 + else 249 249 + () (* \p is literal 'p' in non-unicode mode *) 250 250 + (* k for named backreference *) 251 251 + | 'k' -> 252 252 + if expect s '<' then begin 253 253 + (* Parse as named backreference syntax *) 254 254 + let start = s.pos in 255 255 + (* Try to parse a valid group name *) 256 256 + let has_valid_name = ref true in 257 257 + while not (is_at_end s) && peek s <> Some '>' do 258 258 + (match peek s with 259 259 + | Some c when (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || 260 260 + (c >= '0' && c <= '9') || c = '_' || c = '$' -> 261 261 + advance s 262 262 + | Some '\\' -> 263 263 + advance s; 264 264 + if expect s 'u' then validate_unicode_escape s 265 265 + else has_valid_name := false 266 266 + | Some c when Char.code c >= 0x80 -> 267 267 + (* Allow Unicode characters (multi-byte UTF-8) *) 268 268 + advance s; 269 269 + while not (is_at_end s) && 270 270 + (match peek s with Some c -> Char.code c >= 0x80 && Char.code c < 0xC0 | None -> false) do 271 271 + advance s 272 272 + done 273 273 + | _ -> has_valid_name := false; advance s) 274 274 + done; 275 275 + let name_len = s.pos - start in 276 276 + if name_len = 0 then has_valid_name := false; 277 277 + let name = String.sub s.pattern start name_len in 278 278 + if not (expect s '>') then 279 279 + has_valid_name := false; 280 280 + (* In unicode mode, require valid syntax immediately *) 281 281 + if is_unicode_mode s then begin 282 282 + if not !has_valid_name then 283 283 + raise (Regexp_error Invalid_backreference); 284 284 + (* Track the backreference for later validation *) 285 285 + s.named_backreferences <- name :: s.named_backreferences 286 286 + end else begin 287 287 + (* In non-unicode mode, \k<name> is only a backreference if there are named groups *) 288 288 + (* If syntax is invalid, mark for deferred error if named groups exist *) 289 289 + if !has_valid_name then 290 290 + s.named_backreferences <- name :: s.named_backreferences 291 291 + else 292 292 + s.has_invalid_k_escape <- true 293 293 + end 294 294 + end else begin 295 295 + (* \k without < - invalid in unicode mode, may be error in non-unicode if named groups exist *) 296 296 + if is_unicode_mode s then 297 297 + raise (Regexp_error (Invalid_escape "\\k")) 298 298 + else 299 299 + s.has_invalid_k_escape <- true 300 300 + end 301 301 + (* q for string literals in unicode sets mode *) 302 302 + | 'q' when s.flags.unicode_sets && in_class -> 303 303 + if not (expect s '{') then 304 304 + raise (Regexp_error (Invalid_escape "\\q")); 305 305 + (* Parse string alternative: \q{str1|str2|...} *) 306 306 + while not (is_at_end s) && peek s <> Some '}' do 307 307 + (match peek s with 308 308 + | Some '\\' -> advance s; validate_escape s ~in_class:true () 309 309 + | Some '|' -> advance s (* Alternative separator *) 310 310 + | Some c when is_line_terminator c -> 311 311 + raise (Regexp_error Line_terminator_in_pattern) 312 312 + | _ when is_unicode_line_terminator s -> 313 313 + raise (Regexp_error Line_terminator_in_pattern) 314 314 + | _ -> advance s) 315 315 + done; 316 316 + if not (expect s '}') then 317 317 + raise (Regexp_error (Invalid_escape "\\q")) 318 318 + (* Other escapes *) 319 319 + | '-' when in_class -> () (* \- in character class *) 320 320 + | _ -> 321 321 + if is_unicode_mode s then begin 322 322 + (* Unicode mode: only specific escapes are allowed *) 323 323 + if not (is_syntax_char c) && c <> '/' then 324 324 + raise (Regexp_error (Invalid_escape (Printf.sprintf "\\%c" c))) 325 325 + end 326 326 + (* Non-unicode mode: identity escape for any character (Annex B) *) 327 327 + 328 328 + and validate_unicode_escape s = 329 329 + if expect s '{' then begin 330 330 + (* \u{HexDigits} form *) 331 331 + let start = s.pos in 332 332 + if not (Option.map is_hex_digit (peek s) = Some true) then 333 333 + raise (Regexp_error Invalid_unicode_escape); 334 334 + while Option.map is_hex_digit (peek s) = Some true do 335 335 + advance s 336 336 + done; 337 337 + (* Check that the value doesn't exceed 0x10FFFF *) 338 338 + let hex = String.sub s.pattern start (s.pos - start) in 339 339 + let value = int_of_string ("0x" ^ hex) in 340 340 + if value > 0x10FFFF then 341 341 + raise (Regexp_error Invalid_unicode_escape); 342 342 + if not (expect s '}') then 343 343 + raise (Regexp_error Invalid_unicode_escape) 344 344 + end else begin 345 345 + (* \uHHHH form *) 346 346 + for _ = 1 to 4 do 347 347 + match peek s with 348 348 + | Some c when is_hex_digit c -> advance s 349 349 + | _ when is_unicode_mode s -> raise (Regexp_error Invalid_unicode_escape) 350 350 + | _ -> () (* Annex B allows \u followed by non-hex *) 351 351 + done 352 352 + end 353 353 + 354 354 + and validate_unicode_property_escape s ~negated ~in_negated_class = 355 355 + if not (expect s '{') then 356 356 + raise (Regexp_error (Invalid_unicode_property "missing {")); 357 357 + let start = s.pos in 358 358 + (* Read property name/value *) 359 359 + while not (is_at_end s) && peek s <> Some '}' && peek s <> Some '=' do 360 360 + advance s 361 361 + done; 362 362 + let name = String.sub s.pattern start (s.pos - start) in 363 363 + let value = 364 364 + if expect s '=' then begin 365 365 + (* Property with value: \p{Name=Value} *) 366 366 + let start2 = s.pos in 367 367 + while not (is_at_end s) && peek s <> Some '}' do 368 368 + advance s 369 369 + done; 370 370 + String.sub s.pattern start2 (s.pos - start2) 371 371 + end else 372 372 + "" 373 373 + in 374 374 + if String.length name = 0 then 375 375 + raise (Regexp_error (Invalid_unicode_property "empty property name")); 376 376 + if not (expect s '}') then 377 377 + raise (Regexp_error (Invalid_unicode_property "missing }")); 378 378 + (* Validate the property name and value *) 379 379 + let unicode_sets = s.flags.unicode_sets in 380 380 + match Unicode_properties.validate_property ~unicode_sets ~name ~value with 381 381 + | Unicode_properties.Sequence_property when negated -> 382 382 + (* \P{...} with sequence property is not allowed *) 383 383 + raise (Regexp_error (Invalid_unicode_property 384 384 + (Printf.sprintf "cannot negate string property '%s'" name))) 385 385 + | Unicode_properties.Sequence_property when in_negated_class -> 386 386 + (* [^\p{...}] with sequence property is not allowed *) 387 387 + raise (Regexp_error (Invalid_unicode_property 388 388 + (Printf.sprintf "cannot use string property '%s' in negated character class" name))) 389 389 + | Unicode_properties.Binary_property 390 390 + | Unicode_properties.Sequence_property 391 391 + | Unicode_properties.General_category 392 392 + | Unicode_properties.Script _ 393 393 + | Unicode_properties.Script_extensions _ -> () 394 394 + | Unicode_properties.Invalid msg -> 395 395 + raise (Regexp_error (Invalid_unicode_property msg)) 396 396 + 397 397 + (* Check if ASCII char is valid identifier start: a-z, A-Z, _, $ *) 398 398 + let is_ascii_id_start c = 399 399 + (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c = '_' || c = '$' 400 400 + 401 401 + (* Check if ASCII char is valid identifier continue: a-z, A-Z, 0-9, _, $ *) 402 402 + let is_ascii_id_continue c = 403 403 + (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || 404 404 + (c >= '0' && c <= '9') || c = '_' || c = '$' 405 405 + 406 406 + (* Decode UTF-8 character and return its codepoint and byte length *) 407 407 + let decode_utf8 s = 408 408 + if is_at_end s then None 409 409 + else 410 410 + let b0 = Char.code s.pattern.[s.pos] in 411 411 + if b0 < 0x80 then Some (b0, 1) 412 412 + else if b0 < 0xC0 then None (* Invalid start byte *) 413 413 + else if b0 < 0xE0 then begin 414 414 + if s.pos + 1 >= String.length s.pattern then None 415 415 + else 416 416 + let b1 = Char.code s.pattern.[s.pos + 1] in 417 417 + if b1 land 0xC0 <> 0x80 then None 418 418 + else Some (((b0 land 0x1F) lsl 6) lor (b1 land 0x3F), 2) 419 419 + end 420 420 + else if b0 < 0xF0 then begin 421 421 + if s.pos + 2 >= String.length s.pattern then None 422 422 + else 423 423 + let b1 = Char.code s.pattern.[s.pos + 1] in 424 424 + let b2 = Char.code s.pattern.[s.pos + 2] in 425 425 + if b1 land 0xC0 <> 0x80 || b2 land 0xC0 <> 0x80 then None 426 426 + else Some (((b0 land 0x0F) lsl 12) lor ((b1 land 0x3F) lsl 6) lor (b2 land 0x3F), 3) 427 427 + end 428 428 + else if b0 < 0xF8 then begin 429 429 + if s.pos + 3 >= String.length s.pattern then None 430 430 + else 431 431 + let b1 = Char.code s.pattern.[s.pos + 1] in 432 432 + let b2 = Char.code s.pattern.[s.pos + 2] in 433 433 + let b3 = Char.code s.pattern.[s.pos + 3] in 434 434 + if b1 land 0xC0 <> 0x80 || b2 land 0xC0 <> 0x80 || b3 land 0xC0 <> 0x80 then None 435 435 + else Some (((b0 land 0x07) lsl 18) lor ((b1 land 0x3F) lsl 12) lor 436 436 + ((b2 land 0x3F) lsl 6) lor (b3 land 0x3F), 4) 437 437 + end 438 438 + else None 439 439 + 440 440 + (* Check if codepoint is valid identifier start (using Uucp) *) 441 441 + let is_id_start cp = 442 442 + (* Check valid Unicode scalar value range (excludes surrogates) *) 443 443 + if cp < 0 || cp > 0x10FFFF then false 444 444 + else if cp >= 0xD800 && cp <= 0xDFFF then false (* Surrogates *) 445 445 + else Uucp.Id.is_id_start (Uchar.of_int cp) 446 446 + 447 447 + (* Check if codepoint is valid identifier continue (using Uucp) *) 448 448 + let is_id_continue cp = 449 449 + (* Check valid Unicode scalar value range (excludes surrogates) *) 450 450 + if cp < 0 || cp > 0x10FFFF then false 451 451 + else if cp >= 0xD800 && cp <= 0xDFFF then false (* Surrogates *) 452 452 + else if cp = 0x200C || cp = 0x200D then true (* ZWNJ and ZWJ *) 453 453 + else Uucp.Id.is_id_continue (Uchar.of_int cp) 454 454 + 455 455 + (* Validates group name and returns the raw name string *) 456 456 + let validate_group_name s = 457 457 + (* Group name must start with ID_Start and continue with ID_Continue *) 458 458 + let is_first = ref true in 459 459 + let has_char = ref false in 460 460 + let name_start = s.pos in 461 461 + while not (is_at_end s) && peek s <> Some '>' do 462 462 + (match peek s with 463 463 + | Some '\\' -> 464 464 + (* Unicode escape in group name *) 465 465 + advance s; 466 466 + if not (expect s 'u') then 467 467 + raise (Regexp_error Invalid_named_capture_group); 468 468 + (* Parse the escaped codepoint *) 469 469 + let cp = 470 470 + if expect s '{' then begin 471 471 + (* \u{HHHH...} form *) 472 472 + let start = s.pos in 473 473 + while Option.map is_hex_digit (peek s) = Some true do advance s done; 474 474 + if s.pos = start then raise (Regexp_error Invalid_named_capture_group); 475 475 + let hex = String.sub s.pattern start (s.pos - start) in 476 476 + if not (expect s '}') then raise (Regexp_error Invalid_named_capture_group); 477 477 + int_of_string ("0x" ^ hex) 478 478 + end else begin 479 479 + (* \uHHHH form *) 480 480 + match peek_n s 4 with 481 481 + | Some hex when String.length hex = 4 && 482 482 + String.for_all (fun c -> is_hex_digit c) hex -> 483 483 + s.pos <- s.pos + 4; 484 484 + let v = int_of_string ("0x" ^ hex) in 485 485 + (* Check for surrogate pair: high surrogate followed by \u low surrogate *) 486 486 + if v >= 0xD800 && v <= 0xDBFF then begin 487 487 + (* High surrogate, check for \u low surrogate *) 488 488 + match peek_n s 6 with 489 489 + | Some seq when String.length seq >= 6 && 490 490 + seq.[0] = '\\' && seq.[1] = 'u' && 491 491 + is_hex_digit seq.[2] && is_hex_digit seq.[3] && 492 492 + is_hex_digit seq.[4] && is_hex_digit seq.[5] -> 493 493 + let low_hex = String.sub seq 2 4 in 494 494 + let low = int_of_string ("0x" ^ low_hex) in 495 495 + if low >= 0xDC00 && low <= 0xDFFF then begin 496 496 + (* Valid surrogate pair, combine them *) 497 497 + s.pos <- s.pos + 6; 498 498 + 0x10000 + ((v - 0xD800) lsl 10) + (low - 0xDC00) 499 499 + end else 500 500 + v (* Not a valid low surrogate, treat high surrogate as-is *) 501 501 + | _ -> v (* No following escape, treat as-is *) 502 502 + end else 503 503 + v 504 504 + | _ -> raise (Regexp_error Invalid_named_capture_group) 505 505 + end 506 506 + in 507 507 + let valid = if !is_first then is_id_start cp else is_id_continue cp in 508 508 + if not valid then raise (Regexp_error Invalid_named_capture_group); 509 509 + has_char := true; 510 510 + is_first := false 511 511 + | Some c when Char.code c < 0x80 -> 512 512 + (* ASCII character *) 513 513 + let valid = if !is_first then is_ascii_id_start c else is_ascii_id_continue c in 514 514 + if not valid then raise (Regexp_error Invalid_named_capture_group); 515 515 + has_char := true; 516 516 + is_first := false; 517 517 + advance s 518 518 + | Some _ -> 519 519 + (* Non-ASCII UTF-8 character *) 520 520 + (match decode_utf8 s with 521 521 + | Some (cp, len) -> 522 522 + let valid = if !is_first then is_id_start cp else is_id_continue cp in 523 523 + if not valid then raise (Regexp_error Invalid_named_capture_group); 524 524 + has_char := true; 525 525 + is_first := false; 526 526 + for _ = 1 to len do advance s done 527 527 + | None -> raise (Regexp_error Invalid_named_capture_group)) 528 528 + | None -> raise (Regexp_error Invalid_named_capture_group)) 529 529 + done; 530 530 + if not !has_char then 531 531 + raise (Regexp_error Invalid_named_capture_group); 532 532 + (* Return the raw name string (including escape sequences) *) 533 533 + String.sub s.pattern name_start (s.pos - name_start) 534 534 + 535 535 + (* Type of class item for range validation *) 536 536 + type class_item = 537 537 + | Literal_char 538 538 + | Character_class_escape (* \d, \s, \w, \p{...}, etc. - multi-char *) 539 539 + | Dash_literal (* A literal dash *) 540 540 + | Empty 541 541 + 542 542 + (* Reserved double punctuators in v-flag mode (excluding && and -- which are operators) *) 543 543 + let is_reserved_double_punct c = 544 544 + c = '!' || c = '#' || c = '$' || c = '%' || c = '*' || c = '+' || 545 545 + c = ',' || c = '.' || c = ':' || c = ';' || c = '<' || c = '=' || 546 546 + c = '>' || c = '?' || c = '@' || c = '^' || c = '`' || c = '~' 547 547 + 548 548 + (* Validate character class *) 549 549 + let rec validate_character_class ?(negated_outer=false) s = 550 550 + (* Skip opening [ *) 551 551 + let negated = expect s '^' in 552 552 + let class_negated = negated || negated_outer in 553 553 + let prev_item = ref Empty in 554 554 + let is_first = ref true in 555 555 + let pending_dash = ref false in (* True when we've seen X- and waiting for end of range *) 556 556 + let had_operand = ref false in (* For v-flag: track if && or -- have left operand *) 557 557 + let pending_operator = ref false in (* For v-flag: waiting for right operand after && or -- *) 558 558 + while not (is_at_end s) && peek s <> Some ']' do 559 559 + let current_item = ref Literal_char in 560 560 + (match peek s with 561 561 + | None -> raise (Regexp_error Unterminated_character_class) 562 562 + | Some '\\' -> 563 563 + advance s; 564 564 + (* Check if this escape produces a character class (multi-char) *) 565 565 + (match peek s with 566 566 + | Some 'd' | Some 'D' | Some 's' | Some 'S' | Some 'w' | Some 'W' -> 567 567 + current_item := Character_class_escape; 568 568 + advance s 569 569 + | Some 'p' | Some 'P' when is_unicode_mode s -> 570 570 + current_item := Character_class_escape; 571 571 + let negated_prop = (peek s = Some 'P') in 572 572 + advance s; 573 573 + validate_unicode_property_escape s ~negated:negated_prop ~in_negated_class:class_negated 574 574 + | _ -> validate_escape s ~in_class:true ~in_negated_class:class_negated ()) 575 575 + | Some '[' when s.flags.unicode_sets -> 576 576 + (* Nested character class in unicode sets mode *) 577 577 + current_item := Character_class_escape; 578 578 + advance s; 579 579 + validate_character_class s ~negated_outer:class_negated 580 580 + | Some c when is_line_terminator c -> 581 581 + raise (Regexp_error Line_terminator_in_pattern) 582 582 + | _ when is_unicode_line_terminator s -> 583 583 + raise (Regexp_error Line_terminator_in_pattern) 584 584 + | Some '-' -> 585 585 + advance s; 586 586 + if s.flags.unicode_sets then begin 587 587 + (* v-flag mode: check for -- operator or range *) 588 588 + if peek s = Some '-' then begin 589 589 + (* -- is the difference operator *) 590 590 + advance s; 591 591 + if not !had_operand then 592 592 + raise (Regexp_error Invalid_class_range); (* No left operand *) 593 593 + current_item := Empty; (* Operator, not an item *) 594 594 + pending_dash := false; 595 595 + pending_operator := true; 596 596 + had_operand := false 597 597 + end else if !is_first then begin 598 598 + (* Dash at start - only valid if followed by more content or range *) 599 599 + if peek s = Some ']' then 600 600 + raise (Regexp_error Invalid_class_range); (* Lone dash not allowed in v-flag *) 601 601 + current_item := Dash_literal 602 602 + end else if peek s = Some ']' then begin 603 603 + (* Dash at end - only valid if there was content before *) 604 604 + (* Actually in v-flag mode, even trailing dash is not allowed *) 605 605 + raise (Regexp_error Invalid_class_range) 606 606 + end else begin 607 607 + (* This is a range: check previous is not a class *) 608 608 + if !prev_item = Character_class_escape then 609 609 + raise (Regexp_error Invalid_class_range); 610 610 + pending_dash := true; 611 611 + current_item := Empty 612 612 + end 613 613 + end else begin 614 614 + (* u-flag mode: standard range syntax *) 615 615 + (* Dash at start is literal *) 616 616 + if !is_first then 617 617 + current_item := Dash_literal 618 618 + (* Dash at end is literal *) 619 619 + else if peek s = Some ']' then 620 620 + current_item := Dash_literal 621 621 + (* Otherwise it's a range operator *) 622 622 + else if is_unicode_mode s then begin 623 623 + (* In Unicode mode, check previous item can be range start *) 624 624 + if !prev_item = Character_class_escape then 625 625 + raise (Regexp_error Invalid_class_range); 626 626 + pending_dash := true; 627 627 + current_item := Empty 628 628 + end else begin 629 629 + (* Non-unicode mode: Annex B allows class escapes as "range" endpoints *) 630 630 + (* Just treat it as a potential range, any issues handled at runtime *) 631 631 + pending_dash := true; 632 632 + current_item := Empty 633 633 + end 634 634 + end 635 635 + | Some '&' when s.flags.unicode_sets -> 636 636 + advance s; 637 637 + if peek s = Some '&' then begin 638 638 + (* && is the intersection operator *) 639 639 + advance s; 640 640 + if not !had_operand then 641 641 + raise (Regexp_error Invalid_class_range); (* No left operand *) 642 642 + current_item := Empty; (* Operator, not an item *) 643 643 + pending_operator := true; 644 644 + had_operand := false 645 645 + end 646 646 + (* Single & is just a literal *) 647 647 + | Some '(' | Some ')' | Some '/' when s.flags.unicode_sets -> 648 648 + (* ( ) / must be escaped in v-flag mode inside character class *) 649 649 + raise (Regexp_error (Invalid_escape (String.make 1 (Option.get (peek s))))) 650 650 + | Some '{' | Some '}' when s.flags.unicode_sets -> 651 651 + (* { and } must be escaped in v-flag mode inside character class *) 652 652 + raise (Regexp_error Lone_quantifier_brackets) 653 653 + | Some '|' when s.flags.unicode_sets -> 654 654 + (* | must be escaped in v-flag mode inside character class *) 655 655 + raise (Regexp_error (Invalid_escape "|")) 656 656 + | Some c when s.flags.unicode_sets && is_reserved_double_punct c -> 657 657 + (* Check for reserved double punctuators *) 658 658 + advance s; 659 659 + if peek s = Some c then 660 660 + raise (Regexp_error (Invalid_escape (Printf.sprintf "%c%c" c c))) 661 661 + (* Single is OK *) 662 662 + | _ -> advance s); 663 663 + (* Check range validity - if we had a pending dash, this is the range end *) 664 664 + if !pending_dash && !current_item <> Empty then begin 665 665 + if is_unicode_mode s && !current_item = Character_class_escape then 666 666 + raise (Regexp_error Invalid_class_range); 667 667 + pending_dash := false 668 668 + end; 669 669 + if !current_item <> Empty then begin 670 670 + prev_item := !current_item; 671 671 + is_first := false; 672 672 + had_operand := true; 673 673 + pending_operator := false 674 674 + end 675 675 + done; 676 676 + (* Check for trailing dash in v-flag mode *) 677 677 + if s.flags.unicode_sets && !pending_dash then 678 678 + raise (Regexp_error Invalid_class_range); 679 679 + (* Check for missing right operand after && or -- *) 680 680 + if s.flags.unicode_sets && !pending_operator then 681 681 + raise (Regexp_error Invalid_class_range); 682 682 + if not (expect s ']') then 683 683 + raise (Regexp_error Unterminated_character_class) 684 684 + 685 685 + (* Check if the next character sequence represents the start of a quantifier *) 686 686 + let is_quantifier_start s = 687 687 + match peek s with 688 688 + | Some '*' | Some '+' | Some '?' -> true 689 689 + | Some '{' -> 690 690 + (* Look ahead to check if it's a valid quantifier *) 691 691 + let saved = s.pos in 692 692 + advance s; (* Skip { *) 693 693 + let has_digits = ref false in 694 694 + while Option.map is_digit (peek s) = Some true do 695 695 + has_digits := true; 696 696 + advance s 697 697 + done; 698 698 + let result = 699 699 + if !has_digits then 700 700 + match peek s with 701 701 + | Some '}' -> true (* {n} *) 702 702 + | Some ',' -> 703 703 + advance s; 704 704 + (* {n,} or {n,m} *) 705 705 + while Option.map is_digit (peek s) = Some true do 706 706 + advance s 707 707 + done; 708 708 + peek s = Some '}' 709 709 + | _ -> false 710 710 + else 711 711 + false 712 712 + in 713 713 + s.pos <- saved; 714 714 + result 715 715 + | _ -> false 716 716 + 717 717 + (* Validate quantifier *) 718 718 + let validate_quantifier s = 719 719 + match consume s with 720 720 + | Some '*' | Some '+' | Some '?' -> 721 721 + let _ = expect s '?' in (* Optional non-greedy modifier *) 722 722 + () 723 723 + | Some '{' -> 724 724 + let n1 = parse_decimal s in 725 725 + (match n1 with 726 726 + | None -> raise (Regexp_error Lone_quantifier_brackets) 727 727 + | Some n1 -> 728 728 + let n2 = 729 729 + if expect s ',' then 730 730 + parse_decimal s 731 731 + else 732 732 + Some n1 733 733 + in 734 734 + if not (expect s '}') then 735 735 + raise (Regexp_error Lone_quantifier_brackets); 736 736 + (* Validate range: n1 <= n2 *) 737 737 + (match n2 with 738 738 + | Some n2 when n2 < n1 -> raise (Regexp_error Invalid_quantifier_range) 739 739 + | _ -> ()); 740 740 + let _ = expect s '?' in (* Optional non-greedy modifier *) 741 741 + ()) 742 742 + | _ -> () 743 743 + 744 744 + (* Atom type for quantifier validation *) 745 745 + type atom_type = 746 746 + | Quantifiable_atom (* Normal atom, can have quantifier *) 747 747 + | Lookahead_assertion (* ?= or ?!, quantifiable only in non-unicode mode *) 748 748 + | Lookbehind_assertion (* ?<= or ?<!, never quantifiable *) 749 749 + | No_atom (* No atom parsed *) 750 750 + 751 751 + (* Validate group, returns true if it's a lookbehind assertion *) 752 752 + let rec validate_group s : atom_type = 753 753 + s.capture_count <- s.capture_count + 1; 754 754 + match peek_n s 2 with 755 755 + | Some "?:" -> 756 756 + (* Non-capturing group *) 757 757 + s.capture_count <- s.capture_count - 1; (* Undo increment *) 758 758 + advance s; advance s; 759 759 + validate_disjunction s; 760 760 + Quantifiable_atom 761 761 + | Some "?=" -> 762 762 + (* Positive lookahead *) 763 763 + s.capture_count <- s.capture_count - 1; 764 764 + advance s; advance s; 765 765 + validate_disjunction s; 766 766 + Lookahead_assertion 767 767 + | Some "?!" -> 768 768 + (* Negative lookahead *) 769 769 + s.capture_count <- s.capture_count - 1; 770 770 + advance s; advance s; 771 771 + validate_disjunction s; 772 772 + Lookahead_assertion 773 773 + | Some "?<" -> 774 774 + advance s; advance s; 775 775 + (match peek s with 776 776 + | Some '=' -> 777 777 + (* Positive lookbehind *) 778 778 + s.capture_count <- s.capture_count - 1; 779 779 + advance s; 780 780 + validate_disjunction s; 781 781 + Lookbehind_assertion 782 782 + | Some '!' -> 783 783 + (* Negative lookbehind *) 784 784 + s.capture_count <- s.capture_count - 1; 785 785 + advance s; 786 786 + validate_disjunction s; 787 787 + Lookbehind_assertion 788 788 + | _ -> 789 789 + (* Named capture group *) 790 790 + let name = validate_group_name s in 791 791 + if not (expect s '>') then 792 792 + raise (Regexp_error Invalid_named_capture_group); 793 793 + (* Check for duplicate group names in the same scope *) 794 794 + if List.exists (fun (n, scope) -> n = name && scope = s.group_name_scope) s.named_groups_with_scope then 795 795 + raise (Regexp_error (Duplicate_capture_group_name name)); 796 796 + s.named_groups <- name :: s.named_groups; 797 797 + s.named_groups_with_scope <- (name, s.group_name_scope) :: s.named_groups_with_scope; 798 798 + validate_disjunction s; 799 799 + Quantifiable_atom) 800 800 + | Some str when String.length str >= 1 && str.[0] = '?' -> 801 801 + (* Check for modifier groups (?ims-ims:...) *) 802 802 + advance s; (* Skip ? *) 803 803 + let is_modifier c = c = 'i' || c = 'm' || c = 's' in 804 804 + let has_modifiers = ref false in 805 805 + let add_flags = ref [] in 806 806 + let remove_flags = ref [] in 807 807 + while Option.map is_modifier (peek s) = Some true do 808 808 + has_modifiers := true; 809 809 + let c = Option.get (peek s) in 810 810 + (* Check for duplicate in add flags *) 811 811 + if List.mem c !add_flags then 812 812 + raise (Regexp_error Invalid_group); 813 813 + add_flags := c :: !add_flags; 814 814 + advance s 815 815 + done; 816 816 + if expect s '-' then begin 817 817 + while Option.map is_modifier (peek s) = Some true do 818 818 + has_modifiers := true; 819 819 + let c = Option.get (peek s) in 820 820 + (* Check for duplicate in remove flags or conflict with add flags *) 821 821 + if List.mem c !remove_flags || List.mem c !add_flags then 822 822 + raise (Regexp_error Invalid_group); 823 823 + remove_flags := c :: !remove_flags; 824 824 + advance s 825 825 + done 826 826 + end; 827 827 + if !has_modifiers && expect s ':' then begin 828 828 + s.capture_count <- s.capture_count - 1; (* Non-capturing *) 829 829 + validate_disjunction s; 830 830 + Quantifiable_atom 831 831 + end else 832 832 + raise (Regexp_error Invalid_group) 833 833 + | _ -> 834 834 + (* Regular capturing group *) 835 835 + validate_disjunction s; 836 836 + Quantifiable_atom 837 837 + 838 838 + (* Validate atom - single element in pattern, returns atom type *) 839 839 + and validate_atom s : atom_type = 840 840 + match peek s with 841 841 + | None -> No_atom 842 842 + | Some ')' | Some '|' -> No_atom 843 843 + | Some '(' -> 844 844 + advance s; 845 845 + let atom_type = validate_group s in 846 846 + if not (expect s ')') then 847 847 + raise (Regexp_error Unterminated_group); 848 848 + atom_type 849 849 + | Some '[' -> 850 850 + advance s; 851 851 + validate_character_class s; 852 852 + Quantifiable_atom 853 853 + | Some '\\' -> 854 854 + advance s; 855 855 + validate_escape s ~in_class:false (); 856 856 + Quantifiable_atom 857 857 + | Some '.' | Some '^' | Some '$' -> 858 858 + advance s; 859 859 + Quantifiable_atom 860 860 + | Some '*' | Some '+' | Some '?' -> 861 861 + (* Quantifier without preceding atom *) 862 862 + raise (Regexp_error Nothing_to_repeat) 863 863 + | Some '{' when is_quantifier_start s -> 864 864 + (* Quantifier without preceding atom *) 865 865 + raise (Regexp_error Lone_quantifier_brackets) 866 866 + | Some '{' when is_unicode_mode s -> 867 867 + (* In unicode mode, lone { is a syntax error *) 868 868 + raise (Regexp_error Lone_quantifier_brackets) 869 869 + | Some '}' when is_unicode_mode s -> 870 870 + (* In unicode mode, lone } is a syntax error *) 871 871 + raise (Regexp_error Lone_quantifier_brackets) 872 872 + | Some c when is_line_terminator c -> 873 873 + raise (Regexp_error Line_terminator_in_pattern) 874 874 + | _ when is_unicode_line_terminator s -> 875 875 + raise (Regexp_error Line_terminator_in_pattern) 876 876 + | Some _ -> 877 877 + advance s; 878 878 + Quantifiable_atom 879 879 + 880 880 + (* Validate term - atom with optional quantifier *) 881 881 + and validate_term s = 882 882 + let atom_type = validate_atom s in 883 883 + match atom_type with 884 884 + | No_atom -> false 885 885 + | _ -> 886 886 + if is_quantifier_start s then begin 887 887 + (* Check if quantifier is allowed on this atom type *) 888 888 + (match atom_type with 889 889 + | Lookbehind_assertion -> 890 890 + (* Lookbehind assertions can never have quantifiers *) 891 891 + raise (Regexp_error Nothing_to_repeat) 892 892 + | Lookahead_assertion when is_unicode_mode s -> 893 893 + (* In unicode mode, lookahead assertions can't have quantifiers *) 894 894 + raise (Regexp_error Nothing_to_repeat) 895 895 + | _ -> ()); 896 896 + validate_quantifier s 897 897 + end; 898 898 + true 899 899 + 900 900 + (* Validate alternative - sequence of terms *) 901 901 + and validate_alternative s = 902 902 + while validate_term s do () done 903 903 + 904 904 + (* Validate disjunction - alternatives separated by | *) 905 905 + and validate_disjunction s = 906 906 + validate_alternative s; 907 907 + while expect s '|' do 908 908 + (* Increment scope for each new alternative *) 909 909 + s.group_name_scope <- s.group_name_scope + 1; 910 910 + validate_alternative s 911 911 + done 912 912 + 913 913 + (* Main validation function *) 914 914 + let validate ~pattern ~flags:flags_str = 915 915 + let flags = validate_flags flags_str in 916 916 + let s = { 917 917 + pattern; 918 918 + pos = 0; 919 919 + flags; 920 920 + capture_count = 0; 921 921 + named_groups = []; 922 922 + named_groups_with_scope = []; 923 923 + named_backreferences = []; 924 924 + max_backreference = 0; 925 925 + has_invalid_k_escape = false; 926 926 + group_name_scope = 0; 927 927 + } in 928 928 + validate_disjunction s; 929 929 + if not (is_at_end s) then 930 930 + raise (Regexp_error Unmatched_paren); 931 931 + (* Validate backreferences don't exceed capture count *) 932 932 + if s.max_backreference > s.capture_count && is_unicode_mode s then 933 933 + raise (Regexp_error Invalid_backreference); 934 934 + (* If we saw invalid \k syntax and there are named groups, it's an error *) 935 935 + if s.has_invalid_k_escape && s.named_groups <> [] then 936 936 + raise (Regexp_error (Invalid_escape "\\k")); 937 937 + (* Validate named backreferences refer to existing groups *) 938 938 + (* Only enforce in unicode mode OR when there are named groups *) 939 939 + if is_unicode_mode s || s.named_groups <> [] then 940 940 + List.iter (fun name -> 941 941 + if not (List.mem name s.named_groups) then 942 942 + raise (Regexp_error Invalid_backreference) 943 943 + ) s.named_backreferences; 944 944 + s.flags

+45

lib/quickjs/parser/regexp_validator.mli

reviewed

··· 1 1 + (** RegExp pattern validator for ECMAScript. *) 2 2 + 3 3 + type error = 4 4 + | Duplicate_flag of char 5 5 + | Invalid_flag of char 6 6 + | Incompatible_flags of char * char 7 7 + | Nothing_to_repeat 8 8 + | Invalid_quantifier_range 9 9 + | Unterminated_group 10 10 + | Unterminated_character_class 11 11 + | Invalid_group 12 12 + | Invalid_escape of string 13 13 + | Invalid_unicode_escape 14 14 + | Invalid_hex_escape 15 15 + | Invalid_control_escape 16 16 + | Invalid_class_range 17 17 + | Lone_quantifier_brackets 18 18 + | Invalid_named_capture_group 19 19 + | Duplicate_capture_group_name of string 20 20 + | Invalid_backreference 21 21 + | Unmatched_paren 22 22 + | Line_terminator_in_pattern 23 23 + | Invalid_unicode_property of string 24 24 + 25 25 + exception Regexp_error of error 26 26 + 27 27 + val pp_error : Format.formatter -> error -> unit 28 28 + val show_error : error -> string 29 29 + 30 30 + (** Regexp flags *) 31 31 + type flags = { 32 32 + global : bool; 33 33 + ignore_case : bool; 34 34 + multiline : bool; 35 35 + dotall : bool; 36 36 + unicode : bool; 37 37 + unicode_sets : bool; 38 38 + sticky : bool; 39 39 + has_indices : bool; 40 40 + } 41 41 + 42 42 + (** Validate a regular expression pattern and flags. 43 43 + Raises [Regexp_error] if the pattern or flags are invalid. 44 44 + Returns the parsed flags on success. *) 45 45 + val validate : pattern:string -> flags:string -> flags

+13 -10

lib/quickjs/parser/token.ml

reviewed

··· 195 195 | Single_quoted 196 196 | Double_quoted 197 197 198 198 - (** Template literal parts *) 198 198 + (** Template literal parts - contains raw and cooked values. 199 199 + cooked is None if the template part contains an invalid escape sequence. *) 199 200 type template_part = 200 200 - | Template_head of string (* `...${ *) 201 201 - | Template_middle of string (* }...${ *) 202 202 - | Template_tail of string (* }...` *) 203 203 - | Template_no_sub of string (* `...` *) 201 201 + | Template_head of { raw : string; cooked : string option } (* `...${ *) 202 202 + | Template_middle of { raw : string; cooked : string option } (* }...${ *) 203 203 + | Template_tail of { raw : string; cooked : string option } (* }...` *) 204 204 + | Template_no_sub of { raw : string; cooked : string option } (* `...` *) 204 205 205 206 (** Token type *) 206 207 type t = ··· 215 216 | Regexp of string * string (* pattern, flags *) 216 217 217 218 (* Identifiers and keywords *) 218 218 - | Identifier of string 219 219 + | Identifier of string (* name - unescaped identifier *) 220 220 + | Escaped_identifier of string (* name - identifier that contained Unicode escapes *) 219 221 | Private_identifier of string (* #name *) 220 222 | Keyword of keyword 221 223 ··· 303 305 | Number (n, _) -> Format.fprintf fmt "Number(%g)" n 304 306 | BigInt s -> Format.fprintf fmt "BigInt(%s)" s 305 307 | String (s, _) -> Format.fprintf fmt "String(%S)" s 306 306 - | Template (Template_head s) -> Format.fprintf fmt "Template_head(%S)" s 307 307 - | Template (Template_middle s) -> Format.fprintf fmt "Template_middle(%S)" s 308 308 - | Template (Template_tail s) -> Format.fprintf fmt "Template_tail(%S)" s 309 309 - | Template (Template_no_sub s) -> Format.fprintf fmt "Template_no_sub(%S)" s 308 308 + | Template (Template_head { raw; _ }) -> Format.fprintf fmt "Template_head(%S)" raw 309 309 + | Template (Template_middle { raw; _ }) -> Format.fprintf fmt "Template_middle(%S)" raw 310 310 + | Template (Template_tail { raw; _ }) -> Format.fprintf fmt "Template_tail(%S)" raw 311 311 + | Template (Template_no_sub { raw; _ }) -> Format.fprintf fmt "Template_no_sub(%S)" raw 310 312 | Regexp (p, f) -> Format.fprintf fmt "Regexp(/%s/%s)" p f 311 313 | Identifier s -> Format.fprintf fmt "Identifier(%s)" s 314 314 + | Escaped_identifier s -> Format.fprintf fmt "Escaped_identifier(%s)" s 312 315 | Private_identifier s -> Format.fprintf fmt "Private_identifier(#%s)" s 313 316 | Keyword kw -> Format.fprintf fmt "Keyword(%s)" (keyword_to_string kw) 314 317 | LBrace -> Format.pp_print_string fmt "{"

+7 -5

lib/quickjs/parser/token.mli

reviewed

··· 75 75 | Single_quoted 76 76 | Double_quoted 77 77 78 78 - (** Template literal parts *) 78 78 + (** Template literal parts - contains raw and cooked values. 79 79 + cooked is None if the template part contains an invalid escape sequence. *) 79 80 type template_part = 80 80 - | Template_head of string 81 81 - | Template_middle of string 82 82 - | Template_tail of string 83 83 - | Template_no_sub of string 81 81 + | Template_head of { raw : string; cooked : string option } 82 82 + | Template_middle of { raw : string; cooked : string option } 83 83 + | Template_tail of { raw : string; cooked : string option } 84 84 + | Template_no_sub of { raw : string; cooked : string option } 84 85 85 86 (** Token type *) 86 87 type t = ··· 91 92 | Template of template_part 92 93 | Regexp of string * string 93 94 | Identifier of string 95 95 + | Escaped_identifier of string 94 96 | Private_identifier of string 95 97 | Keyword of keyword 96 98 | LBrace

+382

lib/quickjs/parser/unicode_properties.ml

reviewed

··· 1 1 + (** Unicode property name validation for ECMAScript RegExp. 2 2 + 3 3 + This module provides validation of Unicode property names used in 4 4 + \p{...} and \P{...} escapes in regular expressions. 5 5 + 6 6 + Based on ECMAScript 2024 specification and Unicode 17.0.0. *) 7 7 + 8 8 + module StringSet = Set.Make(String) 9 9 + 10 10 + (* Valid binary properties - ECMAScript supports a subset of Unicode binary properties. 11 11 + Names are case-sensitive and must match exactly. *) 12 12 + let binary_properties = StringSet.of_list [ 13 13 + (* Canonical names and their aliases *) 14 14 + "ASCII"; 15 15 + "ASCII_Hex_Digit"; "AHex"; 16 16 + "Alphabetic"; "Alpha"; 17 17 + "Any"; 18 18 + "Assigned"; 19 19 + "Bidi_Control"; "Bidi_C"; 20 20 + "Bidi_Mirrored"; "Bidi_M"; 21 21 + "Case_Ignorable"; "CI"; 22 22 + "Cased"; 23 23 + "Changes_When_Casefolded"; "CWCF"; 24 24 + "Changes_When_Casemapped"; "CWCM"; 25 25 + "Changes_When_Lowercased"; "CWL"; 26 26 + "Changes_When_NFKC_Casefolded"; "CWKCF"; 27 27 + "Changes_When_Titlecased"; "CWT"; 28 28 + "Changes_When_Uppercased"; "CWU"; 29 29 + "Dash"; 30 30 + "Default_Ignorable_Code_Point"; "DI"; 31 31 + "Deprecated"; "Dep"; 32 32 + "Diacritic"; "Dia"; 33 33 + "Emoji"; 34 34 + "Emoji_Component"; "EComp"; 35 35 + "Emoji_Modifier"; "EMod"; 36 36 + "Emoji_Modifier_Base"; "EBase"; 37 37 + "Emoji_Presentation"; "EPres"; 38 38 + "Extended_Pictographic"; "ExtPict"; 39 39 + "Extender"; "Ext"; 40 40 + "Grapheme_Base"; "Gr_Base"; 41 41 + "Grapheme_Extend"; "Gr_Ext"; 42 42 + "Hex_Digit"; "Hex"; 43 43 + "ID_Continue"; "IDC"; 44 44 + "ID_Start"; "IDS"; 45 45 + "Ideographic"; "Ideo"; 46 46 + "IDS_Binary_Operator"; "IDSB"; 47 47 + "IDS_Trinary_Operator"; "IDST"; 48 48 + "IDS_Unary_Operator"; "IDSU"; 49 49 + "Join_Control"; "Join_C"; 50 50 + "Logical_Order_Exception"; "LOE"; 51 51 + "Lowercase"; "Lower"; 52 52 + "Math"; 53 53 + "Modifier_Combining_Mark"; "MCM"; 54 54 + "Noncharacter_Code_Point"; "NChar"; 55 55 + "Pattern_Syntax"; "Pat_Syn"; 56 56 + "Pattern_White_Space"; "Pat_WS"; 57 57 + "Quotation_Mark"; "QMark"; 58 58 + "Radical"; 59 59 + "Regional_Indicator"; "RI"; 60 60 + "Sentence_Terminal"; "STerm"; 61 61 + "Soft_Dotted"; "SD"; 62 62 + "Terminal_Punctuation"; "Term"; 63 63 + "Unified_Ideograph"; "UIdeo"; 64 64 + "Uppercase"; "Upper"; 65 65 + "Variation_Selector"; "VS"; 66 66 + "White_Space"; "space"; 67 67 + "XID_Continue"; "XIDC"; 68 68 + "XID_Start"; "XIDS"; 69 69 + ] 70 70 + 71 71 + (* Valid General_Category values *) 72 72 + let general_categories = StringSet.of_list [ 73 73 + (* Letter *) 74 74 + "L"; "Letter"; 75 75 + "LC"; "Cased_Letter"; 76 76 + "Lu"; "Uppercase_Letter"; 77 77 + "Ll"; "Lowercase_Letter"; 78 78 + "Lt"; "Titlecase_Letter"; 79 79 + "Lm"; "Modifier_Letter"; 80 80 + "Lo"; "Other_Letter"; 81 81 + (* Mark *) 82 82 + "M"; "Mark"; "Combining_Mark"; 83 83 + "Mn"; "Nonspacing_Mark"; 84 84 + "Mc"; "Spacing_Mark"; 85 85 + "Me"; "Enclosing_Mark"; 86 86 + (* Number *) 87 87 + "N"; "Number"; 88 88 + "Nd"; "Decimal_Number"; "digit"; 89 89 + "Nl"; "Letter_Number"; 90 90 + "No"; "Other_Number"; 91 91 + (* Punctuation *) 92 92 + "P"; "Punctuation"; "punct"; 93 93 + "Pc"; "Connector_Punctuation"; 94 94 + "Pd"; "Dash_Punctuation"; 95 95 + "Ps"; "Open_Punctuation"; 96 96 + "Pe"; "Close_Punctuation"; 97 97 + "Pi"; "Initial_Punctuation"; 98 98 + "Pf"; "Final_Punctuation"; 99 99 + "Po"; "Other_Punctuation"; 100 100 + (* Symbol *) 101 101 + "S"; "Symbol"; 102 102 + "Sm"; "Math_Symbol"; 103 103 + "Sc"; "Currency_Symbol"; 104 104 + "Sk"; "Modifier_Symbol"; 105 105 + "So"; "Other_Symbol"; 106 106 + (* Separator *) 107 107 + "Z"; "Separator"; 108 108 + "Zs"; "Space_Separator"; 109 109 + "Zl"; "Line_Separator"; 110 110 + "Zp"; "Paragraph_Separator"; 111 111 + (* Other *) 112 112 + "C"; "Other"; 113 113 + "Cc"; "Control"; "cntrl"; 114 114 + "Cf"; "Format"; 115 115 + "Cs"; "Surrogate"; 116 116 + "Co"; "Private_Use"; 117 117 + "Cn"; "Unassigned"; 118 118 + ] 119 119 + 120 120 + (* Valid Script values - from Unicode 17.0.0 *) 121 121 + let scripts = StringSet.of_list [ 122 122 + "Adlam"; "Adlm"; 123 123 + "Ahom"; 124 124 + "Anatolian_Hieroglyphs"; "Hluw"; 125 125 + "Arabic"; "Arab"; 126 126 + "Armenian"; "Armn"; 127 127 + "Avestan"; "Avst"; 128 128 + "Balinese"; "Bali"; 129 129 + "Bamum"; "Bamu"; 130 130 + "Bassa_Vah"; "Bass"; 131 131 + "Batak"; "Batk"; 132 132 + "Bengali"; "Beng"; 133 133 + "Bhaiksuki"; "Bhks"; 134 134 + "Bopomofo"; "Bopo"; 135 135 + "Brahmi"; "Brah"; 136 136 + "Braille"; "Brai"; 137 137 + "Buginese"; "Bugi"; 138 138 + "Buhid"; "Buhd"; 139 139 + "Canadian_Aboriginal"; "Cans"; 140 140 + "Carian"; "Cari"; 141 141 + "Caucasian_Albanian"; "Aghb"; 142 142 + "Chakma"; "Cakm"; 143 143 + "Cham"; 144 144 + "Cherokee"; "Cher"; 145 145 + "Chorasmian"; "Chrs"; 146 146 + "Common"; "Zyyy"; 147 147 + "Coptic"; "Copt"; "Qaac"; 148 148 + "Cuneiform"; "Xsux"; 149 149 + "Cypriot"; "Cprt"; 150 150 + "Cypro_Minoan"; "Cpmn"; 151 151 + "Cyrillic"; "Cyrl"; 152 152 + "Deseret"; "Dsrt"; 153 153 + "Devanagari"; "Deva"; 154 154 + "Dives_Akuru"; "Diak"; 155 155 + "Dogra"; "Dogr"; 156 156 + "Duployan"; "Dupl"; 157 157 + "Egyptian_Hieroglyphs"; "Egyp"; 158 158 + "Elbasan"; "Elba"; 159 159 + "Elymaic"; "Elym"; 160 160 + "Ethiopic"; "Ethi"; 161 161 + "Georgian"; "Geor"; 162 162 + "Glagolitic"; "Glag"; 163 163 + "Gothic"; "Goth"; 164 164 + "Grantha"; "Gran"; 165 165 + "Greek"; "Grek"; 166 166 + "Gujarati"; "Gujr"; 167 167 + "Gunjala_Gondi"; "Gong"; 168 168 + "Gurmukhi"; "Guru"; 169 169 + "Han"; "Hani"; 170 170 + "Hangul"; "Hang"; 171 171 + "Hanifi_Rohingya"; "Rohg"; 172 172 + "Hanunoo"; "Hano"; 173 173 + "Hatran"; "Hatr"; 174 174 + "Hebrew"; "Hebr"; 175 175 + "Hiragana"; "Hira"; 176 176 + "Imperial_Aramaic"; "Armi"; 177 177 + "Inherited"; "Zinh"; "Qaai"; 178 178 + "Inscriptional_Pahlavi"; "Phli"; 179 179 + "Inscriptional_Parthian"; "Prti"; 180 180 + "Javanese"; "Java"; 181 181 + "Kaithi"; "Kthi"; 182 182 + "Kannada"; "Knda"; 183 183 + "Katakana"; "Kana"; 184 184 + "Kawi"; 185 185 + "Kayah_Li"; "Kali"; 186 186 + "Kharoshthi"; "Khar"; 187 187 + "Khitan_Small_Script"; "Kits"; 188 188 + "Khmer"; "Khmr"; 189 189 + "Khojki"; "Khoj"; 190 190 + "Khudawadi"; "Sind"; 191 191 + "Lao"; "Laoo"; 192 192 + "Latin"; "Latn"; 193 193 + "Lepcha"; "Lepc"; 194 194 + "Limbu"; "Limb"; 195 195 + "Linear_A"; "Lina"; 196 196 + "Linear_B"; "Linb"; 197 197 + "Lisu"; 198 198 + "Lycian"; "Lyci"; 199 199 + "Lydian"; "Lydi"; 200 200 + "Mahajani"; "Mahj"; 201 201 + "Makasar"; "Maka"; 202 202 + "Malayalam"; "Mlym"; 203 203 + "Mandaic"; "Mand"; 204 204 + "Manichaean"; "Mani"; 205 205 + "Marchen"; "Marc"; 206 206 + "Masaram_Gondi"; "Gonm"; 207 207 + "Medefaidrin"; "Medf"; 208 208 + "Meetei_Mayek"; "Mtei"; 209 209 + "Mende_Kikakui"; "Mend"; 210 210 + "Meroitic_Cursive"; "Merc"; 211 211 + "Meroitic_Hieroglyphs"; "Mero"; 212 212 + "Miao"; "Plrd"; 213 213 + "Modi"; 214 214 + "Mongolian"; "Mong"; 215 215 + "Mro"; "Mroo"; 216 216 + "Multani"; "Mult"; 217 217 + "Myanmar"; "Mymr"; 218 218 + "Nabataean"; "Nbat"; 219 219 + "Nag_Mundari"; "Nagm"; 220 220 + "Nandinagari"; "Nand"; 221 221 + "New_Tai_Lue"; "Talu"; 222 222 + "Newa"; 223 223 + "Nko"; "Nkoo"; 224 224 + "Nushu"; "Nshu"; 225 225 + "Nyiakeng_Puachue_Hmong"; "Hmnp"; 226 226 + "Ogham"; "Ogam"; 227 227 + "Ol_Chiki"; "Olck"; 228 228 + "Old_Hungarian"; "Hung"; 229 229 + "Old_Italic"; "Ital"; 230 230 + "Old_North_Arabian"; "Narb"; 231 231 + "Old_Permic"; "Perm"; 232 232 + "Old_Persian"; "Xpeo"; 233 233 + "Old_Sogdian"; "Sogo"; 234 234 + "Old_South_Arabian"; "Sarb"; 235 235 + "Old_Turkic"; "Orkh"; 236 236 + "Old_Uyghur"; "Ougr"; 237 237 + "Oriya"; "Orya"; 238 238 + "Osage"; "Osge"; 239 239 + "Osmanya"; "Osma"; 240 240 + "Pahawh_Hmong"; "Hmng"; 241 241 + "Palmyrene"; "Palm"; 242 242 + "Pau_Cin_Hau"; "Pauc"; 243 243 + "Phags_Pa"; "Phag"; 244 244 + "Phoenician"; "Phnx"; 245 245 + "Psalter_Pahlavi"; "Phlp"; 246 246 + "Rejang"; "Rjng"; 247 247 + "Runic"; "Runr"; 248 248 + "Samaritan"; "Samr"; 249 249 + "Saurashtra"; "Saur"; 250 250 + "Sharada"; "Shrd"; 251 251 + "Shavian"; "Shaw"; 252 252 + "Siddham"; "Sidd"; 253 253 + "SignWriting"; "Sgnw"; 254 254 + "Sinhala"; "Sinh"; 255 255 + "Sogdian"; "Sogd"; 256 256 + "Sora_Sompeng"; "Sora"; 257 257 + "Soyombo"; "Soyo"; 258 258 + "Sundanese"; "Sund"; 259 259 + "Sunuwar"; "Sunu"; 260 260 + "Syloti_Nagri"; "Sylo"; 261 261 + "Syriac"; "Syrc"; 262 262 + "Tagalog"; "Tglg"; 263 263 + "Tagbanwa"; "Tagb"; 264 264 + "Tai_Le"; "Tale"; 265 265 + "Tai_Tham"; "Lana"; 266 266 + "Tai_Viet"; "Tavt"; 267 267 + "Takri"; "Takr"; 268 268 + "Tamil"; "Taml"; 269 269 + "Tangsa"; "Tnsa"; 270 270 + "Tangut"; "Tang"; 271 271 + "Telugu"; "Telu"; 272 272 + "Thaana"; "Thaa"; 273 273 + "Thai"; 274 274 + "Tibetan"; "Tibt"; 275 275 + "Tifinagh"; "Tfng"; 276 276 + "Tirhuta"; "Tirh"; 277 277 + "Todhri"; "Todr"; 278 278 + "Toto"; 279 279 + "Tulu_Tigalari"; "Tutg"; 280 280 + "Ugaritic"; "Ugar"; 281 281 + "Vai"; "Vaii"; 282 282 + "Vithkuqi"; "Vith"; 283 283 + "Wancho"; "Wcho"; 284 284 + "Warang_Citi"; "Wara"; 285 285 + "Yezidi"; "Yezi"; 286 286 + "Yi"; "Yiii"; 287 287 + "Zanabazar_Square"; "Zanb"; 288 288 + (* Unicode 17.0 additions *) 289 289 + "Garay"; "Gara"; 290 290 + "Gurung_Khema"; "Gukh"; 291 291 + "Kirat_Rai"; "Krai"; 292 292 + "Tolong_Siki"; "Tols"; 293 293 + "Beria_Erfe"; "Berf"; 294 294 + "Ol_Onal"; "Onao"; 295 295 + "Sidetic"; "Sidt"; 296 296 + "Tai_Yo"; "Tayo"; 297 297 + (* Special value *) 298 298 + "Unknown"; "Zzzz"; 299 299 + ] 300 300 + 301 301 + (* Sequence properties - valid only in unicode sets mode (v flag) *) 302 302 + let sequence_properties = StringSet.of_list [ 303 303 + "Basic_Emoji"; 304 304 + "Emoji_Keycap_Sequence"; 305 305 + "RGI_Emoji"; 306 306 + "RGI_Emoji_Flag_Sequence"; 307 307 + "RGI_Emoji_Modifier_Sequence"; 308 308 + "RGI_Emoji_Tag_Sequence"; 309 309 + "RGI_Emoji_ZWJ_Sequence"; 310 310 + ] 311 311 + 312 312 + (* Property names that are NOT valid in ECMAScript (deprecated or never supported) *) 313 313 + let invalid_binary_properties = StringSet.of_list [ 314 314 + "Composition_Exclusion"; 315 315 + "Expands_On_NFC"; 316 316 + "Expands_On_NFD"; 317 317 + "Expands_On_NFKC"; 318 318 + "Expands_On_NFKD"; 319 319 + "FC_NFKC_Closure"; 320 320 + "Full_Composition_Exclusion"; 321 321 + "Grapheme_Link"; 322 322 + "Hyphen"; 323 323 + "ISO_Comment"; 324 324 + "Other_Alphabetic"; 325 325 + "Other_Default_Ignorable_Code_Point"; 326 326 + "Other_Grapheme_Extend"; 327 327 + "Other_ID_Continue"; 328 328 + "Other_ID_Start"; 329 329 + "Other_Lowercase"; 330 330 + "Other_Math"; 331 331 + "Other_Uppercase"; 332 332 + "Prepended_Concatenation_Mark"; 333 333 + ] 334 334 + 335 335 + (* Validate a binary property name *) 336 336 + let is_valid_binary_property name = 337 337 + StringSet.mem name binary_properties && 338 338 + not (StringSet.mem name invalid_binary_properties) 339 339 + 340 340 + (* Validate a General_Category value *) 341 341 + let is_valid_general_category name = 342 342 + StringSet.mem name general_categories 343 343 + 344 344 + (* Validate a Script value *) 345 345 + let is_valid_script name = 346 346 + StringSet.mem name scripts 347 347 + 348 348 + (* Validate a sequence property name (valid only in v flag mode) *) 349 349 + let is_valid_sequence_property name = 350 350 + StringSet.mem name sequence_properties 351 351 + 352 352 + (* Main validation function for \p{...} syntax *) 353 353 + type property_result = 354 354 + | Binary_property 355 355 + | Sequence_property 356 356 + | General_category 357 357 + | Script of string 358 358 + | Script_extensions of string 359 359 + | Invalid of string 360 360 + 361 361 + let validate_property ~unicode_sets ~name ~value = 362 362 + match value with 363 363 + | "" -> 364 364 + (* No value - could be binary property, sequence property, or general category *) 365 365 + if is_valid_binary_property name then Binary_property 366 366 + else if unicode_sets && is_valid_sequence_property name then Sequence_property 367 367 + else if is_valid_general_category name then General_category 368 368 + else Invalid (Printf.sprintf "unknown property '%s'" name) 369 369 + | _ -> 370 370 + (* Has value - must be Script, Script_Extensions, or General_Category *) 371 371 + match name with 372 372 + | "Script" | "sc" -> 373 373 + if is_valid_script value then Script value 374 374 + else Invalid (Printf.sprintf "unknown script '%s'" value) 375 375 + | "Script_Extensions" | "scx" -> 376 376 + if is_valid_script value then Script_extensions value 377 377 + else Invalid (Printf.sprintf "unknown script '%s'" value) 378 378 + | "General_Category" | "gc" -> 379 379 + if is_valid_general_category value then General_category 380 380 + else Invalid (Printf.sprintf "unknown general category '%s'" value) 381 381 + | _ -> 382 382 + Invalid (Printf.sprintf "unknown property '%s'" name)

+4

test/runner/dune

reviewed

··· 12 12 (executable 13 13 (name debug_async) 14 14 (libraries quickjs)) 15 15 + 16 16 + (executable 17 17 + (name test_parse) 18 18 + (libraries quickjs))

+13

test/runner/quick_let_test.ml

reviewed

··· 1 1 + let () = 2 2 + let code = {|let 3 3 + let;|} in 4 4 + let lexer = Lexer.create ~filename:"test" code in 5 5 + let parser = Parser.create lexer in 6 6 + try 7 7 + let _ = Parser.parse_program parser in 8 8 + print_endline "SUCCESS - no error" 9 9 + with 10 10 + | Parser.Parse_error (err, _) -> 11 11 + Printf.printf "PARSE ERROR: %s\n" (Parser.show_error err) 12 12 + | exn -> 13 13 + Printf.printf "OTHER ERROR: %s\n" (Printexc.to_string exn)

+15 -21

test/runner/quick_test.ml

reviewed

··· 1 1 let () = 2 2 - let tests = [ 3 3 - ("async function expression", {|let f = async function f(p, q) { };|}); 4 4 - ("generator function expression", {|let f = function* f() { yield 1; };|}); 5 5 - ("async generator function expression", {|let f = async function* f() { yield 1; };|}); 6 6 - ("generator method", {|var o = { *gen() { yield 1; } };|}); 7 7 - ("async method", {|var o = { async foo() { await 1; } };|}); 8 8 - ("async generator method", {|var o = { async *gen() { yield 1; } };|}); 9 9 - ("class declaration", {|class C { foo() {} }|}); 10 10 - ("async function decl", {|async function f() {}|}); 11 11 - ("async generator decl", {|async function* f() {}|}); 12 12 - ] in 13 13 - List.iter (fun (name, code) -> 2 2 + Printexc.record_backtrace true; 3 3 + (* test extends as shorthand in arrow params - should error *) 4 4 + let code = "var x = ({ extends }) => {};" in 5 5 + Printf.printf "Testing: %s\n" code; 6 6 + try 14 7 let lexer = Quickjs.Lexer.create ~filename:"test.js" ~content:code in 15 8 let parser = Quickjs.Parser.create lexer in 16 16 - try 17 17 - let _ = Quickjs.Parser.parse_program parser in 18 18 - Printf.printf "OK: %s\n" name 19 19 - with 20 20 - | Quickjs.Parser.Parse_error (err, _loc) -> 21 21 - Printf.printf "FAIL: %s - %s\n" name (Quickjs.Parser.show_error err) 22 22 - | Quickjs.Lexer.Lexer_error (err, _loc) -> 23 23 - Printf.printf "FAIL: %s - %s\n" name (Quickjs.Lexer.show_error err) 24 24 - ) tests 9 9 + let prog = Quickjs.Parser.parse_program parser in 10 10 + Printf.printf "OK - parsed successfully! Body has %d items\n" (List.length prog.Quickjs_parser.Ast.body) 11 11 + with 12 12 + | Quickjs_parser.Parser.Parse_error (err, loc) -> 13 13 + Printf.printf "FAIL at %d:%d - %s\n" loc.Quickjs_parser.Source.start.line loc.Quickjs_parser.Source.start.column (Quickjs_parser.Parser.show_error err) 14 14 + | Quickjs_parser.Lexer.Lexer_error (err, loc) -> 15 15 + Printf.printf "FAIL at %d:%d - %s\n" loc.Quickjs_parser.Source.start.line loc.Quickjs_parser.Source.start.column (Quickjs_parser.Lexer.show_error err) 16 16 + | e -> 17 17 + Printf.printf "Unexpected exception: %s\n" (Printexc.to_string e); 18 18 + Printexc.print_backtrace stdout

+235 -205

test/runner/test262_runner.ml

reviewed

··· 1 1 (** Test262 test runner for ocaml-quickjs. 2 2 3 3 This runner executes ECMAScript Test262 conformance tests against 4 4 - our JavaScript implementation. *) 4 4 + our JavaScript parser implementation. It validates parsing behavior 5 5 + against the official ECMAScript conformance test suite. 6 6 + 7 7 + {2 Usage} 5 8 9 9 + {[ 10 10 + # Run all tests 11 11 + dune exec test/runner/test262_runner.exe 12 12 + 13 13 + # Run a single test 14 14 + dune exec test/runner/test262_runner.exe -- --test path/to/test.js 15 15 + 16 16 + # Verbose output 17 17 + dune exec test/runner/test262_runner.exe -- --verbose 18 18 + ]} 19 19 + 20 20 + {2 Test Metadata} 21 21 + 22 22 + Test262 tests contain YAML frontmatter that specifies expected behavior, 23 23 + required features, and whether parse errors are expected (negative tests). *) 24 24 + 25 25 + (** {1 Result Types} *) 26 26 + 27 27 + (** Test execution result. *) 6 28 type result = 7 7 - | Pass 8 8 - | Fail of string 9 9 - | Skip of string 10 10 - | Timeout 11 11 - | Error of string 29 29 + | Pass (** Test passed *) 30 30 + | Fail of string (** Test failed with error message *) 31 31 + | Skip of string (** Test skipped with reason *) 32 32 + | Timeout (** Test exceeded time limit *) 33 33 + | Error of string (** Internal error during test execution *) 12 34 35 35 + (** {1 Test Metadata} *) 36 36 + 37 37 + (** Metadata parsed from test file YAML frontmatter. *) 13 38 type test_metadata = { 14 14 - description : string; 15 15 - es5id : string option; 16 16 - es6id : string option; 17 17 - esid : string option; 18 18 - info : string option; 19 19 - negative : negative option; 20 20 - includes : string list; 21 21 - flags : string list; 22 22 - features : string list; 23 23 - locale : string list; 39 39 + description : string; (** Human-readable test description *) 40 40 + es5id : string option; (** ES5 specification section ID *) 41 41 + es6id : string option; (** ES6 specification section ID *) 42 42 + esid : string option; (** Current spec section ID *) 43 43 + info : string option; (** Additional information *) 44 44 + negative : negative option; (** Expected error for negative tests *) 45 45 + includes : string list; (** Harness files to include *) 46 46 + flags : string list; (** Test flags (onlyStrict, module, etc.) *) 47 47 + features : string list; (** Required language features *) 48 48 + locale : string list; (** Required locales *) 24 49 } 25 50 51 51 + (** Expected error specification for negative tests. *) 26 52 and negative = { 27 27 - phase : string; (* "parse", "resolution", "runtime" *) 28 28 - type_ : string; (* Error type expected *) 53 53 + phase : string; (** Error phase: "parse", "resolution", or "runtime" *) 54 54 + type_ : string; (** Expected error type name *) 29 55 } 30 56 57 57 + (** {1 Configuration} *) 58 58 + 59 59 + (** Test runner configuration. *) 31 60 type config = { 32 32 - test_dir : string; 33 33 - harness_dir : string; 34 34 - timeout_ms : int; 35 35 - features : string list; 36 36 - skip_patterns : string list; 37 37 - verbose : bool; 61 61 + test_dir : string; (** Directory containing test files *) 62 62 + harness_dir : string; (** Directory containing harness helpers *) 63 63 + timeout_ms : int; (** Test timeout in milliseconds *) 64 64 + features : string list; (** Features to enable *) 65 65 + skip_patterns : string list; (** Patterns of tests to skip *) 66 66 + verbose : bool; (** Enable verbose output *) 38 67 } 39 68 69 69 + (** Default configuration for standard test262 layout. *) 40 70 let default_config = { 41 71 test_dir = "vendor/git/test262/test"; 42 72 harness_dir = "vendor/git/test262/harness"; ··· 46 76 verbose = false; 47 77 } 48 78 49 49 - (* Parse YAML frontmatter from test file *) 79 79 + (** {1 Metadata Parsing} *) 80 80 + 81 81 + (** Default metadata with empty/none values. *) 82 82 + let empty_metadata = { 83 83 + description = ""; 84 84 + es5id = None; 85 85 + es6id = None; 86 86 + esid = None; 87 87 + info = None; 88 88 + negative = None; 89 89 + includes = []; 90 90 + flags = []; 91 91 + features = []; 92 92 + locale = []; 93 93 + } 94 94 + 95 95 + (** [parse_metadata content] extracts test metadata from YAML frontmatter. 96 96 + Returns [empty_metadata] if no frontmatter is found. *) 50 97 let parse_metadata content = 51 51 - let default = { 52 52 - description = ""; 53 53 - es5id = None; 54 54 - es6id = None; 55 55 - esid = None; 56 56 - info = None; 57 57 - negative = None; 58 58 - includes = []; 59 59 - flags = []; 60 60 - features = []; 61 61 - locale = []; 62 62 - } in 63 63 - (* Find /*--- ... ---*/ block *) 64 98 let start_marker = "/*---" in 65 99 let end_marker = "---*/" in 66 100 match Str.search_forward (Str.regexp_string start_marker) content 0 with 67 67 - | exception Not_found -> default 101 101 + | exception Not_found -> empty_metadata 68 102 | start -> 69 103 match Str.search_forward (Str.regexp_string end_marker) content (start + 5) with 70 70 - | exception Not_found -> default 104 104 + | exception Not_found -> empty_metadata 71 105 | end_pos -> 72 106 let yaml_content = String.sub content (start + 5) (end_pos - start - 5) in 73 73 - (* Simple YAML-like parsing *) 74 74 - let lines = String.split_on_char '\n' yaml_content in 107 107 + let lines = String.split_on_char '\n' yaml_content in 75 108 76 76 - (* Parse inline list format like [item1, item2] *) 77 77 - let parse_inline_list s = 78 78 - if String.length s >= 2 && s.[0] = '[' && s.[String.length s - 1] = ']' then 79 79 - let inner = String.sub s 1 (String.length s - 2) in 80 80 - String.split_on_char ',' inner 81 81 - |> List.map String.trim 82 82 - |> List.filter (fun s -> String.length s > 0) 83 83 - else [] 84 84 - in 109 109 + (* Parse inline list format like [item1, item2] *) 110 110 + let parse_inline_list s = 111 111 + if String.length s >= 2 && s.[0] = '[' && s.[String.length s - 1] = ']' then 112 112 + let inner = String.sub s 1 (String.length s - 2) in 113 113 + String.split_on_char ',' inner 114 114 + |> List.map String.trim 115 115 + |> List.filter (fun s -> String.length s > 0) 116 116 + else [] 117 117 + in 85 118 86 86 - (* Parse a list of values that follow a key (indented lines starting with -) *) 87 87 - let rec parse_list acc = function 88 88 - | [] -> (List.rev acc, []) 89 89 - | line :: rest -> 90 90 - let trimmed = String.trim line in 91 91 - if String.length trimmed > 0 && trimmed.[0] = '-' then 92 92 - let item = String.trim (String.sub trimmed 1 (String.length trimmed - 1)) in 93 93 - parse_list (item :: acc) rest 94 94 - else if String.length line > 0 && line.[0] = ' ' then 95 95 - (* Indented non-list line, skip *) 96 96 - parse_list acc rest 97 97 - else 98 98 - (List.rev acc, line :: rest) 99 99 - in 119 119 + (* Parse YAML list items (indented lines starting with -) *) 120 120 + let rec parse_list acc = function 121 121 + | [] -> (List.rev acc, []) 122 122 + | line :: rest -> 123 123 + let trimmed = String.trim line in 124 124 + if String.length trimmed > 0 && trimmed.[0] = '-' then 125 125 + let item = String.trim (String.sub trimmed 1 (String.length trimmed - 1)) in 126 126 + parse_list (item :: acc) rest 127 127 + else if String.length line > 0 && line.[0] = ' ' then 128 128 + parse_list acc rest 129 129 + else 130 130 + (List.rev acc, line :: rest) 131 131 + in 100 132 101 101 - (* Parse nested block like negative: *) 102 102 - let rec parse_block acc = function 103 103 - | [] -> (acc, []) 104 104 - | line :: rest -> 105 105 - if String.length line > 0 && line.[0] = ' ' then 106 106 - let trimmed = String.trim line in 107 107 - (match String.index_opt trimmed ':' with 108 108 - | Some colon -> 109 109 - let key = String.trim (String.sub trimmed 0 colon) in 110 110 - let value = String.trim (String.sub trimmed (colon + 1) (String.length trimmed - colon - 1)) in 111 111 - parse_block ((key, value) :: acc) rest 112 112 - | None -> parse_block acc rest) 113 113 - else 114 114 - (acc, line :: rest) 115 115 - in 133 133 + (* Parse nested YAML block (indented key: value pairs) *) 134 134 + let rec parse_block acc = function 135 135 + | [] -> (acc, []) 136 136 + | line :: rest when String.length line > 0 && line.[0] = ' ' -> 137 137 + let trimmed = String.trim line in 138 138 + begin match String.index_opt trimmed ':' with 139 139 + | Some colon -> 140 140 + let key = String.trim (String.sub trimmed 0 colon) in 141 141 + let value = String.trim (String.sub trimmed (colon + 1) (String.length trimmed - colon - 1)) in 142 142 + parse_block ((key, value) :: acc) rest 143 143 + | None -> parse_block acc rest 144 144 + end 145 145 + | lines -> (acc, lines) 146 146 + in 116 147 117 117 - let rec parse_lines acc = function 118 118 - | [] -> acc 119 119 - | line :: rest -> 120 120 - let trimmed = String.trim line in 121 121 - if String.length trimmed = 0 then 122 122 - parse_lines acc rest 123 123 - else 124 124 - match String.index_opt trimmed ':' with 125 125 - | None -> parse_lines acc rest 126 126 - | Some colon -> 127 127 - let key = String.trim (String.sub trimmed 0 colon) in 128 128 - let value = String.trim (String.sub trimmed (colon + 1) (String.length trimmed - colon - 1)) in 129 129 - match key with 130 130 - | "description" -> 131 131 - parse_lines { acc with description = value } rest 132 132 - | "es5id" -> 133 133 - parse_lines { acc with es5id = Some value } rest 134 134 - | "es6id" -> 135 135 - parse_lines { acc with es6id = Some value } rest 136 136 - | "esid" -> 137 137 - parse_lines { acc with esid = Some value } rest 138 138 - | "negative" -> 139 139 - let (fields, rest') = parse_block [] rest in 140 140 - let phase = List.assoc_opt "phase" fields |> Option.value ~default:"" in 141 141 - let type_ = List.assoc_opt "type" fields |> Option.value ~default:"" in 142 142 - parse_lines { acc with negative = Some { phase; type_ } } rest' 143 143 - | "features" -> 144 144 - if String.length value > 0 && value.[0] = '[' then 145 145 - parse_lines { acc with features = parse_inline_list value } rest 146 146 - else 147 147 - let (items, rest') = parse_list [] rest in 148 148 - parse_lines { acc with features = items } rest' 149 149 - | "includes" -> 150 150 - if String.length value > 0 && value.[0] = '[' then 151 151 - parse_lines { acc with includes = parse_inline_list value } rest 152 152 - else 153 153 - let (items, rest') = parse_list [] rest in 154 154 - parse_lines { acc with includes = items } rest' 155 155 - | "flags" -> 156 156 - if String.length value > 0 && value.[0] = '[' then 157 157 - parse_lines { acc with flags = parse_inline_list value } rest 158 158 - else 159 159 - let (items, rest') = parse_list [] rest in 160 160 - parse_lines { acc with flags = items } rest' 161 161 - | _ -> 162 162 - parse_lines acc rest 163 163 - in 164 164 - parse_lines default lines 148 148 + (* Parse all top-level YAML entries *) 149 149 + let rec parse_lines acc = function 150 150 + | [] -> acc 151 151 + | line :: rest -> 152 152 + let trimmed = String.trim line in 153 153 + if String.length trimmed = 0 then 154 154 + parse_lines acc rest 155 155 + else 156 156 + match String.index_opt trimmed ':' with 157 157 + | None -> parse_lines acc rest 158 158 + | Some colon -> 159 159 + let key = String.trim (String.sub trimmed 0 colon) in 160 160 + let value = String.trim (String.sub trimmed (colon + 1) (String.length trimmed - colon - 1)) in 161 161 + match key with 162 162 + | "description" -> parse_lines { acc with description = value } rest 163 163 + | "es5id" -> parse_lines { acc with es5id = Some value } rest 164 164 + | "es6id" -> parse_lines { acc with es6id = Some value } rest 165 165 + | "esid" -> parse_lines { acc with esid = Some value } rest 166 166 + | "negative" -> 167 167 + let fields, rest' = parse_block [] rest in 168 168 + let phase = Option.value ~default:"" (List.assoc_opt "phase" fields) in 169 169 + let type_ = Option.value ~default:"" (List.assoc_opt "type" fields) in 170 170 + parse_lines { acc with negative = Some { phase; type_ } } rest' 171 171 + | "features" -> 172 172 + if String.length value > 0 && value.[0] = '[' then 173 173 + parse_lines { acc with features = parse_inline_list value } rest 174 174 + else 175 175 + let items, rest' = parse_list [] rest in 176 176 + parse_lines { acc with features = items } rest' 177 177 + | "includes" -> 178 178 + if String.length value > 0 && value.[0] = '[' then 179 179 + parse_lines { acc with includes = parse_inline_list value } rest 180 180 + else 181 181 + let items, rest' = parse_list [] rest in 182 182 + parse_lines { acc with includes = items } rest' 183 183 + | "flags" -> 184 184 + if String.length value > 0 && value.[0] = '[' then 185 185 + parse_lines { acc with flags = parse_inline_list value } rest 186 186 + else 187 187 + let items, rest' = parse_list [] rest in 188 188 + parse_lines { acc with flags = items } rest' 189 189 + | _ -> parse_lines acc rest 190 190 + in 191 191 + parse_lines empty_metadata lines 165 192 166 166 - (* Check if test should be skipped *) 167 167 - let should_skip (config : config) (filename : string) (metadata : test_metadata) : string option = 168 168 - (* Skip if uses unsupported features *) 169 169 - let unsupported_features = [ 170 170 - (* We can incrementally add support and remove from this list *) 171 171 - "Atomics"; "SharedArrayBuffer"; 172 172 - (* Platform-specific *) 173 173 - "caller"; 174 174 - ] in 175 175 - let uses_unsupported = List.exists (fun f -> 176 176 - List.mem f unsupported_features 177 177 - ) metadata.features in 178 178 - if uses_unsupported then 179 179 - Some ("Unsupported feature: " ^ String.concat ", " metadata.features) 180 180 - else 181 181 - (* Check skip patterns *) 182 182 - let matches_skip = List.exists (fun pattern -> 193 193 + (** {1 Test Filtering} *) 194 194 + 195 195 + (** [should_skip config filename metadata] returns [Some reason] if the test 196 196 + should be skipped, [None] otherwise. *) 197 197 + let should_skip (config : config) (filename : string) (_metadata : test_metadata) : string option = 198 198 + let matches_skip = 199 199 + List.exists (fun pattern -> 183 200 Str.string_match (Str.regexp pattern) filename 0 184 184 - ) config.skip_patterns in 185 185 - if matches_skip then Some "Matched skip pattern" 186 186 - else None 201 201 + ) config.skip_patterns 202 202 + in 203 203 + if matches_skip then Some "Matched skip pattern" else None 187 204 188 188 - (* Load harness file *) 205 205 + (** {1 Harness Loading} *) 206 206 + 207 207 + (** [load_harness config name] loads a harness helper file. 208 208 + Returns [None] if the file cannot be read. *) 189 209 let load_harness config name = 190 210 let path = Filename.concat config.harness_dir name in 191 211 try ··· 196 216 Some s 197 217 with _ -> None 198 218 199 199 - (* Run a single test *) 219 219 + (** {1 Test Execution} *) 220 220 + 221 221 + (** [run_test config filename] executes a single test file. 222 222 + Handles strict mode, module mode, and negative test expectations. *) 200 223 let run_test config filename = 201 224 try 202 225 let ic = open_in filename in ··· 205 228 206 229 let metadata = parse_metadata content in 207 230 208 208 - (* Check if should skip *) 209 231 match should_skip config filename metadata with 210 232 | Some reason -> Skip reason 211 233 | None -> 212 212 - (* Handle strict mode flags *) 234 234 + (* Handle strict mode flag *) 235 235 + let is_strict = List.mem "onlyStrict" metadata.flags in 213 236 let content = 214 214 - if List.mem "onlyStrict" metadata.flags then 215 215 - "\"use strict\";\n" ^ content 216 216 - else 217 217 - content 237 237 + if is_strict then "\"use strict\";\n" ^ content else content 218 238 in 219 239 (* Check if this is a module *) 220 240 let is_module = List.mem "module" metadata.flags in 221 241 (* Try to lex and parse the file *) 222 222 - (try 242 242 + begin try 223 243 let lexer = Quickjs.Lexer.create ~filename ~content in 244 244 + if is_strict || is_module then Quickjs.Lexer.set_strict_mode lexer true; 224 245 let parser = Quickjs.Parser.create lexer in 225 246 let _program = Quickjs.Parser.parse_program ~is_module parser in 226 247 (* If negative test expecting parse error, this is a failure *) 227 227 - (match metadata.negative with 228 228 - | Some { phase = "parse"; _ } -> Fail "Expected parse error but succeeded" 229 229 - | _ -> Pass) 248 248 + match metadata.negative with 249 249 + | Some { phase = "parse"; _ } -> Fail "Expected parse error but succeeded" 250 250 + | _ -> Pass 230 251 with 231 252 | Quickjs.Lexer.Lexer_error (err, _loc) -> 232 232 - (* If negative test expecting this error, it's a pass *) 233 233 - (match metadata.negative with 234 234 - | Some { phase = "parse"; _ } -> Pass 235 235 - | _ -> Fail (Quickjs.Lexer.show_error err)) 253 253 + begin match metadata.negative with 254 254 + | Some { phase = "parse"; _ } -> Pass 255 255 + | _ -> Fail (Quickjs.Lexer.show_error err) 256 256 + end 236 257 | Quickjs.Parser.Parse_error (err, _loc) -> 237 237 - (* If negative test expecting this error, it's a pass *) 238 238 - (match metadata.negative with 239 239 - | Some { phase = "parse"; _ } -> Pass 240 240 - | _ -> Fail (Quickjs.Parser.show_error err))) 258 258 + begin match metadata.negative with 259 259 + | Some { phase = "parse"; _ } -> Pass 260 260 + | _ -> Fail (Quickjs.Parser.show_error err) 261 261 + end 262 262 + end 241 263 with 242 264 | Sys_error msg -> Error msg 243 265 | exn -> Error (Printexc.to_string exn) 244 266 245 245 - (* Collect all test files *) 267 267 + (** {1 Test Collection} *) 268 268 + 269 269 + (** [collect_tests dir] recursively finds all test files in [dir]. 270 270 + Excludes fixture files (ending in [_FIXTURE.js]) which are helper modules. *) 246 271 let collect_tests dir = 247 272 let rec walk acc path = 248 273 if Sys.is_directory path then ··· 251 276 walk acc (Filename.concat path entry) 252 277 ) acc entries 253 278 else if Filename.check_suffix path ".js" then 254 254 - path :: acc 279 279 + (* Skip fixture files - helper modules, not actual tests *) 280 280 + if Str.string_match (Str.regexp ".*_FIXTURE\\.js$") path 0 then acc 281 281 + else path :: acc 255 282 else 256 283 acc 257 284 in 258 285 walk [] dir 259 286 260 260 - (* Run all tests and collect results *) 287 287 + (** {1 Test Suite Execution} *) 288 288 + 289 289 + (** [run_all config] executes all tests and prints a summary. 290 290 + Returns 0 on success (no failures or errors), 1 otherwise. *) 261 291 let run_all config = 262 292 let tests = collect_tests config.test_dir in 263 293 let total = List.length tests in ··· 270 300 if config.verbose then 271 301 Printf.printf "[%d/%d] %s..." (i + 1) total filename; 272 302 273 273 - let result = run_test config filename in 274 274 - 275 275 - (match result with 276 276 - | Pass -> 277 277 - incr pass; 278 278 - if config.verbose then print_endline " PASS" 279 279 - | Fail msg -> 280 280 - incr fail; 281 281 - if config.verbose then Printf.printf " FAIL: %s\n" msg 282 282 - else Printf.printf "FAIL: %s - %s\n" filename msg 283 283 - | Skip msg -> 284 284 - incr skip; 285 285 - if config.verbose then Printf.printf " SKIP: %s\n" msg 286 286 - | Timeout -> 287 287 - incr fail; 288 288 - if config.verbose then print_endline " TIMEOUT" 289 289 - | Error msg -> 290 290 - incr error; 291 291 - if config.verbose then Printf.printf " ERROR: %s\n" msg); 303 303 + match run_test config filename with 304 304 + | Pass -> 305 305 + incr pass; 306 306 + if config.verbose then print_endline " PASS" 307 307 + | Fail msg -> 308 308 + incr fail; 309 309 + if config.verbose then Printf.printf " FAIL: %s\n" msg 310 310 + else Printf.printf "FAIL: %s - %s\n" filename msg 311 311 + | Skip msg -> 312 312 + incr skip; 313 313 + if config.verbose then Printf.printf " SKIP: %s\n" msg 314 314 + | Timeout -> 315 315 + incr fail; 316 316 + if config.verbose then print_endline " TIMEOUT" 317 317 + | Error msg -> 318 318 + incr error; 319 319 + if config.verbose then Printf.printf " ERROR: %s\n" msg 292 320 ) tests; 293 321 294 322 Printf.printf "\n=== Test262 Results ===\n"; ··· 300 328 301 329 if !fail = 0 && !error = 0 then 0 else 1 302 330 303 303 - (* Command line interface *) 331 331 + (** {1 Command Line Interface} *) 332 332 + 304 333 let () = 305 334 let test_dir = ref default_config.test_dir in 306 335 let harness_dir = ref default_config.harness_dir in 307 336 let verbose = ref false in 308 337 let single_test = ref None in 309 338 310 310 - let usage = "qjs-test262 [options]" in 339 339 + let usage = "test262_runner [options]" in 311 340 let speclist = [ 312 312 - ("--test-dir", Arg.Set_string test_dir, "Test262 test directory"); 313 313 - ("--harness-dir", Arg.Set_string harness_dir, "Test262 harness directory"); 314 314 - ("--verbose", Arg.Set verbose, "Verbose output"); 315 315 - ("--test", Arg.String (fun s -> single_test := Some s), "Run single test file"); 341 341 + ("--test-dir", Arg.Set_string test_dir, " Test262 test directory"); 342 342 + ("--harness-dir", Arg.Set_string harness_dir, " Test262 harness directory"); 343 343 + ("--verbose", Arg.Set verbose, " Verbose output"); 344 344 + ("--test", Arg.String (fun s -> single_test := Some s), " Run single test file"); 316 345 ] in 317 346 318 347 Arg.parse speclist (fun _ -> ()) usage; ··· 324 353 verbose = !verbose; 325 354 } in 326 355 327 327 - let exit_code = match !single_test with 356 356 + let exit_code = 357 357 + match !single_test with 328 358 | Some filename -> 329 329 - (match run_test config filename with 330 330 - | Pass -> print_endline "PASS"; 0 331 331 - | Fail msg -> Printf.printf "FAIL: %s\n" msg; 1 332 332 - | Skip msg -> Printf.printf "SKIP: %s\n" msg; 0 333 333 - | Timeout -> print_endline "TIMEOUT"; 1 334 334 - | Error msg -> Printf.printf "ERROR: %s\n" msg; 1) 335 335 - | None -> 336 336 - run_all config 359 359 + begin match run_test config filename with 360 360 + | Pass -> print_endline "PASS"; 0 361 361 + | Fail msg -> Printf.printf "FAIL: %s\n" msg; 1 362 362 + | Skip msg -> Printf.printf "SKIP: %s\n" msg; 0 363 363 + | Timeout -> print_endline "TIMEOUT"; 1 364 364 + | Error msg -> Printf.printf "ERROR: %s\n" msg; 1 365 365 + end 366 366 + | None -> run_all config 337 367 in 338 368 exit exit_code

+12

test/runner/test_parse.ml

reviewed

··· 1 1 + let () = 2 2 + let code = Sys.argv.(1) in 3 3 + let lexer = Quickjs.Lexer.create ~filename:"test.js" ~content:code in 4 4 + let parser = Quickjs.Parser.create lexer in 5 5 + try 6 6 + let _ = Quickjs.Parser.parse_program parser in 7 7 + Printf.printf "OK\n" 8 8 + with 9 9 + | Quickjs.Parser.Parse_error (err, _loc) -> 10 10 + Printf.printf "PARSE_ERROR: %s\n" (Quickjs.Parser.show_error err) 11 11 + | Quickjs.Lexer.Lexer_error (err, _loc) -> 12 12 + Printf.printf "LEXER_ERROR: %s\n" (Quickjs.Lexer.show_error err)

+12

test/test_parse.ml

reviewed

··· 1 1 + let () = 2 2 + let code = Sys.argv.(1) in 3 3 + let lexer = Quickjs.Lexer.create ~filename:"test.js" ~content:code in 4 4 + let parser = Quickjs.Parser.create lexer in 5 5 + try 6 6 + let _ = Quickjs.Parser.parse_program parser in 7 7 + Printf.printf "OK\n" 8 8 + with 9 9 + | Quickjs.Parser.Parse_error (err, _loc) -> 10 10 + Printf.printf "PARSE_ERROR: %s\n" (Quickjs.Parser.show_error err) 11 11 + | Quickjs.Lexer.Lexer_error (err, _loc) -> 12 12 + Printf.printf "LEXER_ERROR: %s\n" (Quickjs.Lexer.show_error err)

+3

test/test_parse_dune

reviewed

··· 1 1 + (executable 2 2 + (name test_parse) 3 3 + (libraries quickjs))