@@ -169,41 +169,12 @@ type as_const_payload = Fixed of string
 
 let as_const (attrs : t) =
   single_as attrs ~decode:(fun ~loc payload ->
-      let is_fixed_value_payload =
-        Ast_payload.is_single_int payload <> None
-        || Ast_payload.semantic_string_of_payload payload <> None
-        ||
-        match Ast_payload.unwrap_payload_expression payload with
-        | PStr
-            [
-              {
-                pstr_desc =
-                  Pstr_eval
-                    ( {
-                        pexp_desc =
-                          Pexp_tagged_template
-                            {
-                              tag =
-                                {pexp_desc = Pexp_ident {txt = Lident "json"}};
-                              raw_sources = [_];
-                              values = [];
-                            };
-                      },
-                      _ );
-              };
-            ] ->
-          true
-        | _ -> false
-      in
-      if not is_fixed_value_payload then
-        Bs_syntaxerr.err loc Expect_int_or_string_or_json_literal;
       match Ast_payload.fixed_source_of_payload payload with
-      | Some source -> (
-        match Classify_function.classify source with
-        | Js_literal _ -> Fixed source
-        | _ ->
-          Location.raise_errorf ~loc
-            "The fixed-value @as payload must be a JavaScript literal")
+      | Some source when Classify_function.is_fixed_literal source ->
+        Fixed source
+      | Some _ ->
+        Location.raise_errorf ~loc
+          "The fixed-value @as payload must be a JavaScript literal"
       | None -> Bs_syntaxerr.err loc Expect_int_or_string_or_json_literal)
 
 let locg = Location.none
 
@@ -392,12 +392,15 @@ type response = {
 }
 
 let fixed_arg_type ({txt = source; loc} : Parsetree.fixed_value) =
-  match Classify_function.classify source with
-  | Js_literal _ ->
+  if Classify_function.is_fixed_literal source then
     External_arg_spec.Arg_cst (External_arg_spec.cst_fixed source)
-  | _ ->
+  else
     Location.raise_errorf ~loc "The %%raw payload must be a JavaScript literal"
 
+(* A fixed argument is always passed, so it has nothing to make optional. *)
+let reject_optional_fixed ({loc} : Parsetree.fixed_value) =
+  Location.raise_errorf ~loc "A %%raw argument cannot be optional"
+
 let process_obj (loc : Location.t) (st : external_desc) (prim_name : string)
     (arg_types_ty : Parsetree.arg list) (result_type : Ast_core_type.t) :
     int * Parsetree.core_type * External_ffi_types.t =
@@ -515,7 +518,7 @@ let process_obj (loc : Location.t) (st : external_desc) (prim_name : string)
               in
               let obj_arg_type =
                 match fixed with
-                | Some value -> fixed_arg_type value
+                | Some value -> reject_optional_fixed value
                 | None -> get_opt_arg_type ~nolabel:false ty
               in
               match obj_arg_type with
@@ -954,7 +957,7 @@ let handle_attributes (loc : Location.t) (type_annotation : Parsetree.core_type)
             | Optional {txt = s} -> (
               let arg_type =
                 match fixed with
-                | Some value -> fixed_arg_type value
+                | Some value -> reject_optional_fixed value
                 | None -> get_opt_arg_type ~nolabel:false ty
               in
               match arg_type with
 
@@ -78,67 +78,51 @@ let semantic_string_of_payload (x : t) =
 let quote_js_string semantic =
   "\"" ^ String_literal.encode_js_string semantic ^ "\""
 
-let rec fixed_source_of_expression (expression : Parsetree.expression) =
-  let map_all f values =
-    let rec loop acc = function
-      | [] -> Some (List.rev acc)
-      | value :: rest -> (
-        match f value with
-        | Some mapped -> loop (mapped :: acc) rest
-        | None -> None)
-    in
-    loop [] values
+(* Spell a ReScript integer literal as a JavaScript one. Underscore separators
+   need ES2021, and a decimal literal with a leading zero is a legacy octal
+   literal, which strict-mode JavaScript rejects. *)
+let js_integer_source source =
+  let source = String.concat "" (String.split_on_char '_' source) in
+  let sign, digits =
+    if source <> "" && source.[0] = '-' then
+      ("-", String.sub source 1 (String.length source - 1))
+    else ("", source)
+  in
+  let length = String.length digits in
+  let has_radix_prefix =
+    length > 1
+    && digits.[0] = '0'
+    &&
+    match digits.[1] with
+    | 'x' | 'X' | 'o' | 'O' | 'b' | 'B' -> true
+    | _ -> false
   in
+  if has_radix_prefix then sign ^ digits
+  else
+    let rec first_significant i =
+      if i < length - 1 && digits.[i] = '0' then first_significant (i + 1)
+      else i
+    in
+    let start = first_significant 0 in
+    sign ^ String.sub digits start (length - start)
+
+let fixed_source_of_expression (expression : Parsetree.expression) =
   match (unwrap_braces expression).pexp_desc with
   | Pexp_constant (Pconst_string payload) ->
     Some (quote_js_string (String_literal.string_semantic payload))
   | Pexp_template {source_segments = [{txt = source}]; values = []} -> (
     match String_literal.decode_js_template_escapes source with
     | Some semantic -> Some (quote_js_string semantic)
     | None -> None)
-  | Pexp_constant (Pconst_integer (source, None)) -> Some source
-  | Pexp_constant (Pconst_integer (source, Some 'n')) -> Some (source ^ "n")
-  | Pexp_constant (Pconst_float (source, None)) -> Some source
+  | Pexp_constant (Pconst_integer (source, None)) ->
+    Some (js_integer_source source)
   | Pexp_tagged_template
       {
         tag = {pexp_desc = Pexp_ident {txt = Lident "json"}};
         raw_sources = [{txt = source}];
         values = [];
       } ->
     Some source
-  | Pexp_construct ({txt = Lident "true"}, {txt = []}) -> Some "true"
-  | Pexp_construct ({txt = Lident "false"}, {txt = []}) -> Some "false"
-  | Pexp_ident {txt = Lident "null"} -> Some "null"
-  | Pexp_ident {txt = Lident "undefined"} -> Some "undefined"
-  | Pexp_array values -> (
-    match map_all fixed_source_of_expression values with
-    | Some values -> Some ("[" ^ String.concat "," values ^ "]")
-    | None -> None)
-  | Pexp_object_literal fields ->
-    let field_source
-        (({txt = name}, value) : string Location.loc * Parsetree.expression) =
-      match fixed_source_of_expression value with
-      | Some value -> Some (quote_js_string name ^ ":" ^ value)
-      | None -> None
-    in
-    begin match map_all field_source fields with
-    | Some fields -> Some ("{" ^ String.concat "," fields ^ "}")
-    | None -> None
-    end
-  | Pexp_record (fields, None) ->
-    let field_source
-        ({lid; x = value; opt} : Parsetree.expression Parsetree.record_element)
-        =
-      if opt then None
-      else
-        match (lid.txt, fixed_source_of_expression value) with
-        | Lident name, Some value -> Some (quote_js_string name ^ ":" ^ value)
-        | Ldot _, _ | _, None -> None
-    in
-    begin match map_all field_source fields with
-    | Some fields -> Some ("{" ^ String.concat "," fields ^ "}")
-    | None -> None
-    end
   | _ -> None
 
 let fixed_source_of_payload (payload : t) =
 
@@ -51,9 +51,10 @@ val semantic_string_of_payload : t -> string option
     Other prefixed literals, such as [json], are not semantic strings. *)
 
 val fixed_source_of_payload : t -> string option
-(** Convert a recursively static literal payload to validated JavaScript source.
-    This does not accept calls, spreads, interpolation, or other executable
-    expressions. *)
+(** The JavaScript source of a legacy fixed-value [@as] payload: an integer, a
+    string, a non-interpolated backquoted string, or a non-interpolated [json]
+    template. Callers still validate the [json] source with
+    [Classify_function.is_fixed_literal]. *)
 
 val is_single_int : t -> int option
 
 
@@ -104,6 +104,24 @@ let classify ?(check : (Location.t * int) option) (prog : string) :
   | Some _, [] | None, [] -> classify_exp prog
   | None, _ :: _ -> Js_exp_unknown
 
+let is_fixed_literal (source : string) : bool =
+  let open Parser_flow in
+  let env = Parser_env.init_env None source in
+  match
+    do_parse env
+      (fun env ->
+        let expression = Parse.expression env in
+        let token = Parser_env.Peek.token env in
+        (* Eating the last token records the comments lexed before it,
+           including those already attached to [expression]. *)
+        Parser_env.Eat.token env;
+        (expression, token, Parser_env.comments env))
+      false
+  with
+  | (expression, Token.T_EOF, []), [] -> is_obj_literal expression
+  | _ -> false
+  | exception _ -> false
+
 let classify_stmt (prog : string) : Js_raw_info.stmt =
   let result = Parser_flow.parse_program false None prog in
   match fst result with
 
@@ -27,3 +27,8 @@ val classify : ?check:Location.t * int -> string -> Js_raw_info.exp
 val classify_exp : (Loc.t, Loc.t) Flow_ast.Expression.t -> Js_raw_info.exp
 
 val classify_stmt : string -> Js_raw_info.stmt
+
+val is_fixed_literal : string -> bool
+(** Whether [source] is exactly one JavaScript literal. The generated code
+    embeds the source verbatim, so trailing tokens, which [classify] ignores,
+    and comments, which could swallow the code that follows, are rejected. *)