Keep attributes in front of a record or open type representation (#8919)

* Keep attributes in front of a record or open type representation

Why:
    The parser accepts attributes between `=` and a record declaration or
    `..` (since #7787) but threw them away, so a PPX such as sury never saw
    `@s.strict`. They now go on the type declaration, after its leading
    attributes, and the formatter prints them in front of `type`. The
    attributed path also passes the inline-record context on, so nested
    record types inside such a record parse.

AST modified (attribute before a record representation):
Example:
    @Schema
    type t = @s.strict {email: string}
Before (parse):
    type_declaration "t"
      attribute  "schema"
        []
      ptype_params =
        []
      ptype_cstrs =
        []
      ptype_kind =
        Ptype_record
    …
After (parse):
    type_declaration "t"
      attribute  "schema"
        []
      attribute  "s.strict"
        []
      ptype_params =
        []
      ptype_cstrs =
        []
      ptype_kind =
        Ptype_record
    …

Diagnostic removed (nested record after an attribute):
Example:
    type u = @attr {x: {y: int}}
Before (diagnostic):
    An inline record type declaration is only allowed in a variant
    constructor's declaration or nested inside of a record type declaration

Format modified (attribute before a record representation):
Example:
    @Schema
    type t = @s.strict {email: string}
    type u = @attr {x: {y: int}}
Before (rescript):
    @Schema
    type t = {email: string}
    // type u: syntax error
After (rescript):
    @Schema @s.strict type t = {email: string}
    @attr type u = {x: {y: int}}

Review: Why the declaration and not an error? The issue asks for the
attribute to reach the PPX, and the declaration is the only parsetree node
a record or open type kind has. An attribute in front of a constructor
still attaches to that constructor.

Fixes #7814

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kr4cjoUi2f5VpMvE6wT9bo
Signed-off-by: Christoph Knittel <ck@cca.io>

* Keep a doc comment in front of a record or open type representation

Why:
    Only a doc comment after an attribute reached the declaration; one
    directly after `=` was parsed as the start of a constructor list and
    failed on `{` or `..`. It now goes through the same lookahead as an
    attribute: in front of `{` or `..` it attaches to the type declaration,
    in front of a constructor it still attaches to that constructor.

AST modified (doc comment before a record representation):
Example:
    type t = /** doc */ {x: int}
Before (diagnostic):
    At this point, I'm looking for an uppercased name like `Array` or `Math`
After (parse):
    type_declaration "t"
      attribute  "res.doc"
        [
          structure_item
            Pstr_eval
            expression
              Pexp_constant PConst_string (source=" doc ", semantic=" doc ")
        ]
      ptype_params =
        []
      ptype_cstrs =
        []
      ptype_kind =
        Ptype_record
    …

Format modified (doc comment before a record or open representation):
Example:
    type t = /** doc */ {x: int}
    type u = /** doc */ ..
After (rescript):
    /** doc */
    type t = {x: int}
    /** doc */
    type u = ..

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kr4cjoUi2f5VpMvE6wT9bo
Signed-off-by: Christoph Knittel <ck@cca.io>

* Share the type representation arm for a doc comment after `=`

The doc comment arm differed from the `Bar | DotDot` arm only in passing
the inline-record context, which the other two never reach, so one arm
serves all three. Behaviour is unchanged; the existing parser and printer
fixtures cover it, so no test is added.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kr4cjoUi2f5VpMvE6wT9bo
Signed-off-by: Christoph Knittel <ck@cca.io>

---------

Signed-off-by: Christoph Knittel <ck@cca.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: cknitt

changes/type-representation-attributes.fix.md

@@ -0,0 +1 @@
+- Keep attributes and doc comments written in front of a record or `..` type representation, attaching them to the type declaration instead of dropping them.

compiler/syntax/src/res_core.ml

@@ -5417,14 +5417,14 @@ and parse_type_representation ?current_type_name_path ?inline_types_context p =
     if Parser.optional p Token.Private then Asttypes.Private
     else Asttypes.Public
   in
-  let kind =
+  let kind, attrs =
     match Parser.peek p with
-    | Bar | Uident _ | DocComment _ ->
-      Parsetree.Ptype_variant (parse_type_constructor_declarations p)
-    | At -> (
-      (* Attributes can prefix either a variant (constructor list), a record, or an
-         open/extensible variant marker (`..`). Peek past attributes and any doc
-         comments to decide which kind it is. *)
+    | Bar | Uident _ ->
+      (Parsetree.Ptype_variant (parse_type_constructor_declarations p), [])
+    | At | DocComment _ -> (
+      (* Attributes and doc comments can prefix either a variant (constructor
+         list), a record, or an open/extensible variant marker (`..`). Peek past
+         them to decide which kind it is. *)
       let after_attrs =
         Parser.lookahead p (fun state ->
             ignore (parse_attributes state);
@@ -5433,37 +5433,39 @@ and parse_type_representation ?current_type_name_path ?inline_types_context p =
       in
       match after_attrs with
       | Lbrace ->
-        (* consume the attributes and any doc comments before the record *)
-        ignore (parse_attributes p);
-        skip_doc_comments p;
-        Parsetree.Ptype_record
-          (parse_record_declaration ?current_type_name_path
-             ?inline_types_context p)
+        (* Attributes (and doc comments) before a record have no node of their
+           own: they are returned so the caller attaches them to the type
+           declaration. *)
+        let attrs = parse_attributes p in
+        ( Parsetree.Ptype_record
+            (parse_record_declaration ?current_type_name_path
+               ?inline_types_context p),
+          attrs )
       | DotDot ->
-        (* attributes before an open variant marker; consume attrs/docs then handle `..` *)
-        ignore (parse_attributes p);
-        skip_doc_comments p;
+        (* Same for attributes before an open variant marker `..`. *)
+        let attrs = parse_attributes p in
         Parser.next p;
         (* consume DotDot *)
-        Ptype_open
+        (Ptype_open, attrs)
       | _ ->
         (* fall back to variant constructor declarations; leave attributes for the
              constructor parsing so they attach to the first constructor. *)
-        Parsetree.Ptype_variant (parse_type_constructor_declarations p))
+        (Parsetree.Ptype_variant (parse_type_constructor_declarations p), []))
     | Lbrace ->
-      Parsetree.Ptype_record
-        (parse_record_declaration ?current_type_name_path ?inline_types_context
-           p)
+      ( Parsetree.Ptype_record
+          (parse_record_declaration ?current_type_name_path
+             ?inline_types_context p),
+        [] )
     | DotDot ->
       Parser.next p;
-      Ptype_open
+      (Ptype_open, [])
     | token ->
       Parser.err p (Diagnostics.unexpected token p.breadcrumbs);
       (* TODO: I have no idea if this is even remotely a good idea *)
-      Parsetree.Ptype_variant []
+      (Parsetree.Ptype_variant [], [])
   in
   Parser.eat_breadcrumb p;
-  (private_flag, kind)
+  (private_flag, kind, attrs)
 
 (* type-param	::=
  *  | variance 'lident
@@ -5614,8 +5616,8 @@ and parse_type_equation_or_constr_decl p =
       match Parser.peek p with
       | Equal ->
         Parser.next p;
-        let priv, kind = parse_type_representation p in
-        (Some typ, priv, kind)
+        let priv, kind, attrs = parse_type_representation p in
+        (Some typ, priv, kind, attrs)
       | EqualGreater ->
         Parser.next p;
         let return_type = parse_typ_expr ~alias:false p in
@@ -5626,8 +5628,8 @@ and parse_type_equation_or_constr_decl p =
             return_type
         in
         let typ = parse_type_alias p arrow_type in
-        (Some typ, Asttypes.Public, Parsetree.Ptype_abstract)
-      | _ -> (Some typ, Asttypes.Public, Parsetree.Ptype_abstract))
+        (Some typ, Asttypes.Public, Parsetree.Ptype_abstract, [])
+      | _ -> (Some typ, Asttypes.Public, Parsetree.Ptype_abstract, []))
     | _ ->
       let uident_end_pos = Parser.position p in
       let args, res = parse_constr_decl_args p in
@@ -5641,12 +5643,12 @@ and parse_type_equation_or_constr_decl p =
       in
       ( None,
         Asttypes.Public,
-        Parsetree.Ptype_variant (parse_type_constructor_declarations p ?first)
-      ))
+        Parsetree.Ptype_variant (parse_type_constructor_declarations p ?first),
+        [] ))
   | t ->
     Parser.err p (Diagnostics.uident t);
     (* TODO: is this a good idea? *)
-    (None, Asttypes.Public, Parsetree.Ptype_abstract)
+    (None, Asttypes.Public, Parsetree.Ptype_abstract, [])
 
 and parse_spread_tail_classified ?current_type_name_path ?inline_types_context
     ~start_pos ~spread_typ ~grammar p =
@@ -5856,18 +5858,18 @@ and parse_private_eq_or_repr p =
   match Parser.peek p with
   | Lbrace ->
     let manifest, _, kind = parse_record_or_object_decl p in
-    (manifest, Asttypes.Private, kind)
+    (manifest, Asttypes.Private, kind, [])
   | Uident _ ->
-    let manifest, _, kind = parse_type_equation_or_constr_decl p in
-    (manifest, Asttypes.Private, kind)
+    let manifest, _, kind, attrs = parse_type_equation_or_constr_decl p in
+    (manifest, Asttypes.Private, kind, attrs)
   | Bar | DotDot ->
-    let _, kind = parse_type_representation p in
-    (None, Asttypes.Private, kind)
+    let _, kind, attrs = parse_type_representation p in
+    (None, Asttypes.Private, kind, attrs)
   | t when Grammar.is_typ_expr_start t ->
-    (Some (parse_typ_expr p), Asttypes.Private, Parsetree.Ptype_abstract)
+    (Some (parse_typ_expr p), Asttypes.Private, Parsetree.Ptype_abstract, [])
   | _ ->
-    let _, kind = parse_type_representation p in
-    (None, Asttypes.Private, kind)
+    let _, kind, attrs = parse_type_representation p in
+    (None, Asttypes.Private, kind, attrs)
 
 (*
   polymorphic-variant-type	::=
@@ -6092,12 +6094,18 @@ and parse_type_equation_and_representation ?current_type_name_path
     match Parser.peek p with
     | Uident _ -> parse_type_equation_or_constr_decl p
     | Lbrace ->
-      parse_record_or_object_decl ?current_type_name_path ?inline_types_context
-        p
+      let manifest, priv, kind =
+        parse_record_or_object_decl ?current_type_name_path
+          ?inline_types_context p
+      in
+      (manifest, priv, kind, [])
     | Private -> parse_private_eq_or_repr p
     | Bar | DotDot | DocComment _ ->
-      let priv, kind = parse_type_representation p in
-      (None, priv, kind)
+      let priv, kind, attrs =
+        parse_type_representation ?current_type_name_path ?inline_types_context
+          p
+      in
+      (None, priv, kind, attrs)
     | At -> (
       (* Attributes can start a representation (variant/record/open variant) or a manifest.
          Look ahead past attributes (and doc comments). If a representation-like token follows,
@@ -6135,31 +6143,34 @@ and parse_type_equation_and_representation ?current_type_name_path
             | _ -> false)
       in
       if is_representation_after_attrs then
-        let priv, kind = parse_type_representation p in
-        (None, priv, kind)
+        let priv, kind, attrs =
+          parse_type_representation ?current_type_name_path
+            ?inline_types_context p
+        in
+        (None, priv, kind, attrs)
       else
         let manifest = Some (parse_typ_expr p) in
         match Parser.peek p with
         | Equal ->
           Parser.next p;
-          let priv, kind =
+          let priv, kind, attrs =
             parse_type_representation ?current_type_name_path
               ?inline_types_context p
           in
-          (manifest, priv, kind)
-        | _ -> (manifest, Public, Parsetree.Ptype_abstract))
+          (manifest, priv, kind, attrs)
+        | _ -> (manifest, Public, Parsetree.Ptype_abstract, []))
     | _ -> (
       let manifest = Some (parse_typ_expr p) in
       match Parser.peek p with
       | Equal ->
         Parser.next p;
-        let priv, kind =
+        let priv, kind, attrs =
           parse_type_representation ?current_type_name_path
             ?inline_types_context p
         in
-        (manifest, priv, kind)
-      | _ -> (manifest, Public, Parsetree.Ptype_abstract)))
-  | _ -> (None, Public, Parsetree.Ptype_abstract)
+        (manifest, priv, kind, attrs)
+      | _ -> (manifest, Public, Parsetree.Ptype_abstract, [])))
+  | _ -> (None, Public, Parsetree.Ptype_abstract, [])
 
 (* type-definition	::=	type [rec] typedef  { and typedef }
  * typedef	::=	typeconstr-name [type-params] type-information
@@ -6176,11 +6187,13 @@ and parse_type_def ~attrs ~start_pos p =
     parse_type_params ~parent:constr_name p
   in
   let type_def =
-    let manifest, priv, kind = parse_type_equation_and_representation p in
+    let manifest, priv, kind, repr_attrs =
+      parse_type_equation_and_representation p
+    in
     let cstrs = parse_type_constraints p in
     let loc = mk_loc start_pos (Parser.position p) in
-    Ast_helper.Type.mk ~loc ~attrs ~priv ~kind ~params ~cstrs ?manifest
-      type_constr_name
+    Ast_helper.Type.mk ~loc ~attrs:(attrs @ repr_attrs) ~priv ~kind ~params
+      ~cstrs ?manifest type_constr_name
   in
   Parser.eat_breadcrumb p;
   type_def
@@ -6224,13 +6237,14 @@ and parse_type_extension ~params ~attrs ~name p =
 and parse_type_definitions ~current_type_name_path ~inline_types_context ~attrs
     ~name ~params ~start_pos p =
   let type_def =
-    let manifest, priv, kind =
+    let manifest, priv, kind, repr_attrs =
       parse_type_equation_and_representation ~current_type_name_path
         ~inline_types_context p
     in
     let cstrs = parse_type_constraints p in
     let loc = mk_loc start_pos (Parser.position p) in
-    Ast_helper.Type.mk ~loc ~attrs ~priv ~kind ~params ~cstrs ?manifest
+    Ast_helper.Type.mk ~loc ~attrs:(attrs @ repr_attrs) ~priv ~kind ~params
+      ~cstrs ?manifest
       {name with txt = lident_of_path name.Location.txt}
   in
   let rec loop p defs =

tests/syntax_tests/data/parsing/grammar/typedefinition/expected/recordDeclaration.res.txt

@@ -55,6 +55,6 @@ type nonrec domProps =
   list: string [@optional ];
   loop: bool [@optional ]}
 type nonrec t = {
-  x: int }
+  x: int }[@@attr ]
 type nonrec t = {
-  x: int }
+  x: int }[@@attr ][@@res.doc {js|doc before record|js}]

tests/syntax_tests/data/parsing/grammar/typedefinition/expected/typeRepresentation.res.txt

@@ -43,8 +43,40 @@ type nonrec t = private {
   x: int ;
   y: int }
 type nonrec t = {
-  x: int }
+  x: int }[@@attr ]
 type nonrec t = {
-  x: int }
-type nonrec t = ..
-type nonrec t = ..
+  x: int }[@@attr ][@@res.doc {js|doc before record|js}]
+type nonrec t = ..[@@attr ]
+type nonrec t = ..[@@attr ][@@res.doc {js|doc before open|js}]
+type t.x = {
+  y: int }
+and t = {
+  x: t.x }[@@attr ]
+type nonrec t = M.t = {
+  x: int }[@@attr ]
+type nonrec 'a t = {
+  x: 'a }[@@attr ]
+type nonrec t = int
+and u = {
+  x: int }[@@attr ]
+type nonrec t = {
+  x: int }[@@res.doc {js|doc before record|js}]
+type nonrec t = ..[@@res.doc {js|doc before open|js}]
+type nonrec t = {
+  x: int }[@@res.doc {js|doc|js}][@@attr ]
+type nonrec t = ..[@@attr ][@@res.doc {js|doc|js}][@@attr2 ]
+type t.x = {
+  y: int }
+and t = {
+  x: t.x }[@@res.doc {js|doc|js}]
+type nonrec t = private {
+  x: int }[@@res.doc {js|doc|js}]
+type nonrec t =
+  | A [@res.doc {js|doc|js}]
+  | B 
+type nonrec t =
+  | A [@res.doc {js|doc|js}]
+  | B [@res.doc {js|doc2|js}]
+type nonrec t =
+  | A [@res.doc {js|doc|js}][@attr ]
+  | B 

tests/syntax_tests/data/parsing/grammar/typedefinition/typeRepresentation.res

@@ -32,3 +32,16 @@ type t = @attr {x: int}
 type t = @attr /**doc before record*/ {x: int}
 type t = @attr ..
 type t = @attr /**doc before open*/ ..
+type t = @attr {x: {y: int}}
+type t = M.t = @attr {x: int}
+type t<'a> = @attr {x: 'a}
+type t = int and u = @attr {x: int}
+type t = /**doc before record*/ {x: int}
+type t = /**doc before open*/ ..
+type t = /**doc*/ @attr {x: int}
+type t = @attr /**doc*/ @attr2 ..
+type t = /**doc*/ {x: {y: int}}
+type t = private /**doc*/ {x: int}
+type t = /**doc*/ A | B
+type t = /**doc*/ | A | /**doc2*/ B
+type t = /**doc*/ @attr A | B

tests/syntax_tests/data/printer/typeDef/attributes.res

@@ -9,3 +9,20 @@ type t = int
 @attrWithSuperLongIdentifeirName @attrWithSuperLongIdentifeirName @attrWithSuperLongIdentifeirName@attrWithSuperLongIdentifeirName type t = string
 @attrWithSuperLongIdentifeirName @attrWithSuperLongIdentifeirName @attrWithSuperLongIdentifeirName@attrWithSuperLongIdentifeirName
 type t = string
+
+// attributes in front of a record or `..` move to the declaration
+@schema
+type t = @s.strict {
+  email: string,
+  name: string,
+}
+type t = @attr /** doc */ {x: int}
+type t = @attr ..
+type t = /** doc */ {x: int}
+type t = /** doc */ ..
+type t = /** doc */ @attr {x: int}
+type t = @attr /** doc */ @attr2 ..
+@outer
+type t = /* c1 */ /** doc */ /* c2 */ {x: int} // trail
+type t = /** doc */ A | B
+type t = | /** doc */ A | /** doc2 */ B

tests/syntax_tests/data/printer/typeDef/expected/attributes.res.txt

@@ -16,3 +16,33 @@ type t = string
 @attrWithSuperLongIdentifeirName
 @attrWithSuperLongIdentifeirName
 type t = string
+
+// attributes in front of a record or `..` move to the declaration
+@schema @s.strict
+type t = {
+  email: string,
+  name: string,
+}
+/** doc */
+@attr type t = {x: int}
+@attr type t = ..
+/** doc */
+type t = {x: int}
+/** doc */
+type t = ..
+/** doc */
+@attr type t = {x: int}
+/** doc */
+@attr @attr2 type t = ..
+/** doc */
+@outer
+type t = {/* c1 */ /* c2 */ x: int} // trail
+type t =
+  /** doc */
+  | A
+  | B
+type t =
+  /** doc */
+  | A
+  /** doc2 */
+  | B