From 041ca7685253fbc9b1d6b52bee31dd8ef5d23925 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Bour?= Date: Wed, 31 Jan 2018 15:47:35 +0900 Subject: [PATCH 1/5] Easy_format: process newlines in strings --- .../vendor/easy_format/easy_format.ml | 33 +++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/src/reason-parser/vendor/easy_format/easy_format.ml b/src/reason-parser/vendor/easy_format/easy_format.ml index 24e6a2890..9a49f52c9 100644 --- a/src/reason-parser/vendor/easy_format/easy_format.ml +++ b/src/reason-parser/vendor/easy_format/easy_format.ml @@ -92,6 +92,35 @@ type escape = type styles = (style_name * style) list +let pp_print_multiline ppf str = + let rec loop i = + match String.index_from str i '\n' with + | exception Not_found -> + (* Lie a bit for the last line: fake it being very long to avoid + the formatted sticking stuff after. + For instance, without this: + /* line 1 + line 2 */ stuff + And with: + /* line 1 + line 2 */ + stuff + *) + pp_print_as ppf + (Format.pp_get_margin ppf () + String.length str) + (String.sub str i (String.length str - i)); + pp_close_box ppf () + | j -> + pp_print_string ppf (String.sub str i (j - i)); + pp_force_newline ppf (); + loop (j + 1) + in + if String.contains str '\n' then ( + pp_open_vbox ppf 0; + loop 0; + ) else + pp_print_string ppf str + (* Transform a tree starting from the leaves, propagating and merging accumulators until reaching the root. @@ -319,10 +348,10 @@ struct let tag_string fmt o s = match o with - None -> pp_print_string fmt s + None -> pp_print_multiline fmt s | Some tag -> pp_open_tag fmt tag; - pp_print_string fmt s; + pp_print_multiline fmt s; pp_close_tag fmt () let rec fprint_t fmt = function From f4066f43e4306056869306b56759cf3692f2394b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Bour?= Date: Wed, 31 Jan 2018 16:11:24 +0900 Subject: [PATCH 2/5] Uniformize comment printing, also align doc comments --- .../expected_output/comments.rei | 12 ++-- .../unit_tests/expected_output/infix.re | 6 +- .../unit_tests/expected_output/syntax.re | 2 +- .../expected_output/wrappingTest.re | 4 +- .../expected_output/wrappingTest.rei | 2 +- src/reason-parser/reason_comment.ml | 54 ++++++++++++++-- src/reason-parser/reason_pprint_ast.ml | 62 ++++--------------- 7 files changed, 73 insertions(+), 69 deletions(-) diff --git a/formatTest/typeCheckedTests/expected_output/comments.rei b/formatTest/typeCheckedTests/expected_output/comments.rei index f309135bc..c93f6fcc1 100644 --- a/formatTest/typeCheckedTests/expected_output/comments.rei +++ b/formatTest/typeCheckedTests/expected_output/comments.rei @@ -34,13 +34,13 @@ /* comment ****/ /* comment *****/ /** - * Multiline - */; + * Multiline + */; /** Multiline - * - */; + * + */; /** - ** - */; + ** + */; diff --git a/formatTest/unit_tests/expected_output/infix.re b/formatTest/unit_tests/expected_output/infix.re index f23599aee..2f39d16c2 100644 --- a/formatTest/unit_tests/expected_output/infix.re +++ b/formatTest/unit_tests/expected_output/infix.re @@ -588,7 +588,8 @@ let containingObject = { x + (something := y); /** * Try with || - */ x.contents + */ + x.contents || something + 1 ? hello : goodbye; @@ -613,7 +614,8 @@ let containingObject = { str.[0] || (something + 1 ? hello : goodbye); /** * Try with && - */ x.contents + */ + x.contents && something + 1 ? hello : goodbye; diff --git a/formatTest/unit_tests/expected_output/syntax.re b/formatTest/unit_tests/expected_output/syntax.re index b7bbcb77c..c410b0c77 100644 --- a/formatTest/unit_tests/expected_output/syntax.re +++ b/formatTest/unit_tests/expected_output/syntax.re @@ -736,7 +736,7 @@ type yourThing = myOtherThing(int, int); */ /** Current OCaml Named Arguments. Any aliasing is more than just aliasing! -OCaml allows full on pattern matching of named args. */ + OCaml allows full on pattern matching of named args. */ /* A: let named ~a ~b = aa + bb in B: let namedAlias ~a:aa ~b:bb = aa + bb in diff --git a/formatTest/unit_tests/expected_output/wrappingTest.re b/formatTest/unit_tests/expected_output/wrappingTest.re index 46d0c58e6..720cbc2fb 100644 --- a/formatTest/unit_tests/expected_output/wrappingTest.re +++ b/formatTest/unit_tests/expected_output/wrappingTest.re @@ -35,7 +35,7 @@ let test = 10; let test = 10; /** This comment will be corrected. - when printed. */ + when printed. */ let test = 10; /** Comments with text on line zero @@ -2900,7 +2900,7 @@ let test = 10; let test = 10; /** This comment will be corrected. - when printed. */ + when printed. */ let test = 10; /** Comments with text on line zero diff --git a/formatTest/unit_tests/expected_output/wrappingTest.rei b/formatTest/unit_tests/expected_output/wrappingTest.rei index bb4a1f6ce..58a712cdc 100644 --- a/formatTest/unit_tests/expected_output/wrappingTest.rei +++ b/formatTest/unit_tests/expected_output/wrappingTest.rei @@ -55,7 +55,7 @@ let test: int; let test: int; /** This comment will be corrected. - when printed. */ + when printed. */ let test: int; /** Comments with text on line zero diff --git a/src/reason-parser/reason_comment.ml b/src/reason-parser/reason_comment.ml index db4873732..abf835f24 100644 --- a/src/reason-parser/reason_comment.ml +++ b/src/reason-parser/reason_comment.ml @@ -35,14 +35,56 @@ let dump ppf t = let dump_list ppf list = List.iter (Format.fprintf ppf "%a\n" dump) list -let wrap t = - match t.text with - | "" | "*" -> "/***/" - | txt when txt.[0] = '*' && txt.[1] <> '*' -> "/**" ^ txt ^ "*/" - | txt -> "/*" ^ txt ^ "*/" - let is_doc t = String.length t.text > 0 && t.text.[0] == '*' let make ~location category text = { text; category; location } + +let align_lines text = + match Syntax_util.split_by ~keep_empty:true (fun x -> x = '\n') text with + | [] -> "" + | [text] -> text + | first :: (second :: _ as rest) -> + let leading_spaces str = + let len = String.length str and i = ref 0 in + while !i < len && str.[!i] = ' ' do incr i done; + !i + in + let smallest_leading_spaces lines = + let rec loop count = function + | [] -> count + | "" :: rest -> loop count rest + | str :: rest -> loop (min (leading_spaces str) count) rest + in + loop max_int lines + in + let begins_with_star str = + let len = String.length str and i = ref 0 in + while !i < len && (str.[!i] = ' ' || str.[!i] = '\t') do incr i done; + (!i < len && str.[!i] = '*') + in + let first_indent = + let len = String.length first and i = ref 1 in + let pred = function ' ' | '\t' | '*' -> true | _ -> false in + while !i < len && pred first.[!i] do incr i done; + if !i = len then 1 else !i + in + let attempt_remove = smallest_leading_spaces rest in + let left_pad = + String.make (if begins_with_star second then 1 else first_indent) ' ' + in + let pad_line = function + | "" -> "" + | s -> + let offset = min attempt_remove (leading_spaces s) in + left_pad ^ String.sub s offset (String.length s - offset) + in + String.concat "\n" (first :: List.map pad_line rest) + +let wrap t = + match t.text with + | "" | "*" -> "/***/" + | txt when txt.[0] = '*' && txt.[1] <> '*' -> + align_lines ("/**" ^ txt ^ "*/") + | txt -> align_lines ("/*" ^ txt ^ "*/") diff --git a/src/reason-parser/reason_pprint_ast.ml b/src/reason-parser/reason_pprint_ast.ml index 2f7a02956..18a7b0442 100644 --- a/src/reason-parser/reason_pprint_ast.ml +++ b/src/reason-parser/reason_pprint_ast.ml @@ -1182,48 +1182,8 @@ let insertBlankLines n term = else makeList ~inline:(true, true) ~indent:0 ~break:Always_rec (Array.to_list (Array.make n (atom "")) @ [term]) -let string_after s n = String.sub s n (String.length s - n) - -(* This is a special-purpose functions only used by `formatComment_`. Notice we -skip a char below during usage because we know the comment starts with `/*` *) -let rec lineZeroMeaningfulContent_ line length idx accum = - if idx = length then None - else - let ch = String.get line idx in - if ch = '\t' || ch = ' ' || ch = '*' then - lineZeroMeaningfulContent_ line length (idx + 1) (accum + 1) - else Some accum - -let lineZeroMeaningfulContent line = - lineZeroMeaningfulContent_ line (String.length line) 1 0 - -let formatComment_ txt = - let commLines = - Syntax_util.split_by ~keep_empty:true (fun x -> x = '\n') - (Comment.wrap txt) - in - match commLines with - | [] -> atom "" - | [hd] -> - atom hd - | zero::one::tl -> - let attemptRemoveCount = (smallestLeadingSpaces (one::tl)) in - let leftPad = - if beginsWithStar one then 1 - else match lineZeroMeaningfulContent zero with - | None -> 1 - | Some num -> num + 1 - in - let padNonOpeningLine s = - let numLeadingSpaceForThisLine = numLeadingSpace s in - if String.length s == 0 then "" - else (String.make leftPad ' ') ^ - (string_after s (min attemptRemoveCount numLeadingSpaceForThisLine)) in - let lines = zero :: List.map padNonOpeningLine (one::tl) in - makeList ~inline:(true, true) ~indent:0 ~break:Always_rec (List.map atom lines) - -let formatComment comment = - source_map ~loc:(Comment.location comment) (formatComment_ comment) +let format_comment comment = + atom ~loc:(Comment.location comment) (Comment.wrap comment) let rec append ?(space=false) txt = function | Layout.SourceMap (loc, sub) -> @@ -1333,7 +1293,7 @@ let rec prependSingleLineComment ?newlinesAboveDocComments:(newlinesAboveDocComm | Sequence (config, hd::tl) when config.break = Always_rec-> Sequence(config, (prependSingleLineComment ~newlinesAboveDocComments comment hd)::tl) | layout -> - let withComment = breakline (formatComment comment) layout in + let withComment = breakline (format_comment comment) layout in if Comment.is_doc comment then insertBlankLines newlinesAboveDocComments withComment else @@ -1359,7 +1319,7 @@ let rec looselyAttachComment ~breakAncestors layout comment = | Layout.SourceMap (loc, sub) -> Layout.SourceMap (loc, looselyAttachComment ~breakAncestors sub comment) | Easy e -> - inline ~postSpace:true layout (formatComment comment) + inline ~postSpace:true layout (format_comment comment) | Sequence (listConfig, subLayouts) when List.exists (Layout.contains_location ~location) subLayouts -> (* If any of the subLayout strictly contains this comment, recurse into to it *) @@ -1371,7 +1331,7 @@ let rec looselyAttachComment ~breakAncestors layout comment = Sequence (listConfig, List.map recurse_sublayout subLayouts) | Sequence (listConfig, subLayouts) when subLayouts == [] -> (* If there are no subLayouts (empty body), create a Sequence of just the comment *) - Sequence (listConfig, [formatComment comment]) + Sequence (listConfig, [format_comment comment]) | Sequence (listConfig, subLayouts) -> let (beforeComment, afterComment) = Syntax_util.pick_while (Layout.is_before ~location) subLayouts in @@ -1413,7 +1373,7 @@ let rec insertSingleLineComment layout comment = prependSingleLineComment comment layout | Sequence (listConfig, subLayouts) when subLayouts = [] -> (* If there are no subLayouts (empty body), create a Sequence of just the comment *) - Sequence (listConfig, [formatComment comment]) + Sequence (listConfig, [format_comment comment]) | Sequence (listConfig, subLayouts) -> let newlinesAboveDocComments = listConfig.newlinesAboveDocComments in let (beforeComment, afterComment) = @@ -1421,7 +1381,7 @@ let rec insertSingleLineComment layout comment = begin match afterComment with (* Nothing in the list is after comment, attach comment to the statement before the comment *) | [] -> - let break sublayout = breakline sublayout (formatComment comment) in + let break sublayout = breakline sublayout (format_comment comment) in Sequence (listConfig, Syntax_util.map_last break beforeComment) | hd::tl -> let afterComment = @@ -1450,7 +1410,7 @@ let rec insertSingleLineComment layout comment = | (Some loc1, Some loc2) when location_is_before location loc2 -> (left, prependSingleLineComment comment right) | _ -> - (left, breakline right (formatComment comment)) + (left, breakline right (format_comment comment)) in Label (formatter, newLeft, newRight) @@ -1463,7 +1423,7 @@ let rec attachCommentToNodeRight layout comment = Layout.Sequence ({config with wrap=(lwrap, rwrap)}, sub) | Layout.SourceMap (loc, sub) -> Layout.SourceMap (loc, attachCommentToNodeRight sub comment) - | layout -> inline ~postSpace:true layout (formatComment comment) + | layout -> inline ~postSpace:true layout (format_comment comment) let rec attachCommentToNodeLeft comment layout = match layout with @@ -1474,7 +1434,7 @@ let rec attachCommentToNodeLeft comment layout = | Layout.SourceMap (loc, sub) -> Layout.SourceMap (loc, attachCommentToNodeLeft comment sub ) | layout -> - Layout.Label (inlineLabel, formatComment comment, layout) + Layout.Label (inlineLabel, format_comment comment, layout) (** [tryPerfectlyAttachComment layout comment] postorderly walk the [layout] and tries * to perfectly attach a comment with a layout node. @@ -5101,7 +5061,7 @@ let printer = object(self:'self) PStr [{ pstr_desc = Pstr_eval ({ pexp_desc = Pexp_constant (Pconst_string(text, None)); _ } , _); pstr_loc; _ }] -> let text = if text = "" then "/**/" else "/**" ^ text ^ "*/" in - makeList ~inline:(true, true) ~postSpace:true ~preSpace:true ~indent:0 ~break:IfNeed [atom ~loc:pstr_loc text] + atom ~loc:pstr_loc (Comment.align_lines text) | (s, e) -> self#payload "@" s e (* [@@ ... ] Attributes that occur after a major item in a structure/class *) From 595625bb30b15c2fff816991c2891b9206237a31 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Bour?= Date: Wed, 31 Jan 2018 16:18:16 +0900 Subject: [PATCH 3/5] Revert "Make lexer not crash on `//`." This reverts commit a816fd48a6c143a17d073cc9b0e98aebca878ce2. --- formatTest/unit_tests/expected_output/basicStructures.re | 2 -- formatTest/unit_tests/input/basicStructures.re | 1 - src/reason-parser/reason_lexer.mll | 4 ++-- 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/formatTest/unit_tests/expected_output/basicStructures.re b/formatTest/unit_tests/expected_output/basicStructures.re index 064014ea8..8f8fb07fa 100644 --- a/formatTest/unit_tests/expected_output/basicStructures.re +++ b/formatTest/unit_tests/expected_output/basicStructures.re @@ -155,8 +155,6 @@ let x = arr^[0] = 1; *============================================================================ */; -let (/\/) = (+); /* // is not a comment */ - let something = if (self.ext.logSuccess) { print_string("Did tap"); diff --git a/formatTest/unit_tests/input/basicStructures.re b/formatTest/unit_tests/input/basicStructures.re index d011f5688..ae6629f0e 100644 --- a/formatTest/unit_tests/input/basicStructures.re +++ b/formatTest/unit_tests/input/basicStructures.re @@ -134,7 +134,6 @@ let x = arr^[0] = 1; *============================================================================ */; -let (//) = (+); /* // is not a comment */ let something = if (self.ext.logSuccess) { print_string("Did tap"); diff --git a/src/reason-parser/reason_lexer.mll b/src/reason-parser/reason_lexer.mll index f56d92931..aabad3aa5 100644 --- a/src/reason-parser/reason_lexer.mll +++ b/src/reason-parser/reason_lexer.mll @@ -195,7 +195,7 @@ let set_lexeme_length buf n = ( ) (* This cut comment characters of the current buffer. - * Operators (including "/*" and "*/") are lexed with the same rule, and this + * Operators (including "/*" and "//") are lexed with the same rule, and this * function cuts the lexeme at the beginning of an operator. *) let lexeme_without_comment buf = ( let lexeme = Lexing.lexeme buf in @@ -203,7 +203,7 @@ let lexeme_without_comment buf = ( let found = ref (-1) in while !i < len && !found = -1 do begin match lexeme.[!i], lexeme.[!i+1] with - | ('/', '*') | ('*', '/') -> + | ('/', '*') | ('/', '/') | ('*', '/') -> found := !i; | _ -> () end; From 0ac583830efe5bd3a40de12e90fd90a9bc852a0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Bour?= Date: Thu, 28 Dec 2017 14:41:54 +0900 Subject: [PATCH 4/5] simple implementation of line comments --- src/reason-parser/reason_comment.ml | 2 ++ src/reason-parser/reason_lexer.mll | 5 +++++ src/reason-parser/reason_toolchain.ml | 5 +++++ src/reason-parser/syntax_util.ml | 8 ++++++++ 4 files changed, 20 insertions(+) diff --git a/src/reason-parser/reason_comment.ml b/src/reason-parser/reason_comment.ml index abf835f24..acc6aca23 100644 --- a/src/reason-parser/reason_comment.ml +++ b/src/reason-parser/reason_comment.ml @@ -85,6 +85,8 @@ let align_lines text = let wrap t = match t.text with | "" | "*" -> "/***/" + | txt when Syntax_util.is_line_comment txt -> + "//" ^ (String.sub txt 0 (String.length txt - 1)) | txt when txt.[0] = '*' && txt.[1] <> '*' -> align_lines ("/**" ^ txt ^ "*/") | txt -> align_lines ("/*" ^ txt ^ "*/") diff --git a/src/reason-parser/reason_lexer.mll b/src/reason-parser/reason_lexer.mll index aabad3aa5..94940ac76 100644 --- a/src/reason-parser/reason_lexer.mll +++ b/src/reason-parser/reason_lexer.mll @@ -636,6 +636,11 @@ rule token = parse } and enter_comment = parse + | "//" ([^'\010']* newline as line) + { update_loc lexbuf None 1 false 0; + COMMENT (line, Location.curr lexbuf) } + | "//" ([^'\010']* eof as line) + { COMMENT (line ^ "\n", Location.curr lexbuf) } | "/*" ("*" "*"+)? { set_lexeme_length lexbuf 2; let start_loc = Location.curr lexbuf in diff --git a/src/reason-parser/reason_toolchain.ml b/src/reason-parser/reason_toolchain.ml index d7a709c36..790d6a128 100644 --- a/src/reason-parser/reason_toolchain.ml +++ b/src/reason-parser/reason_toolchain.ml @@ -219,6 +219,11 @@ module Create_parse_entrypoint (Toolchain_impl: Toolchain_spec) :Toolchain = str else String.unsafe_get contents (virtual_start_pos - 2) in + if Syntax_util.is_line_comment str then + Comment.make ~location:physical_loc + (if eol_start then Comment.SingleLine else Comment.EndOfLine) + str :: classifiedTail + else (* * * The following logic are designed for cases like: diff --git a/src/reason-parser/syntax_util.ml b/src/reason-parser/syntax_util.ml index bd07037ec..ba0bda0db 100644 --- a/src/reason-parser/syntax_util.ml +++ b/src/reason-parser/syntax_util.ml @@ -419,6 +419,14 @@ let apply_mapper_to_toplevel_phrase toplevel_phrase mapper = let apply_mapper_to_use_file use_file mapper = List.map (fun x -> apply_mapper_to_toplevel_phrase x mapper) use_file +(* A line comment is a comment that ends with a newline and doesn't contain + any other newline characters *) +let is_line_comment str = + (* true iff the first \n is the last character *) + match String.index str '\n' with + | exception Not_found -> false + | n -> n = String.length str - 1 + (* The following logic defines our own Error object * and register it with ocaml so it knows how to print it *) From f635609114f13720a1863f2d2d01b32d671bf7f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Bour?= Date: Wed, 31 Jan 2018 19:51:16 +0900 Subject: [PATCH 5/5] test single line comments --- .../expected_output/reasonLineComments.re | 734 ++++++++++++++++++ .../expected_output/reasonLineComments.rei | 3 + .../input/reasonLineComments.re | 713 +++++++++++++++++ .../input/reasonLineComments.rei | 3 + src/reason-parser/reason_comment.ml | 2 +- .../vendor/easy_format/easy_format.ml | 7 + 6 files changed, 1461 insertions(+), 1 deletion(-) create mode 100644 formatTest/typeCheckedTests/expected_output/reasonLineComments.re create mode 100644 formatTest/typeCheckedTests/expected_output/reasonLineComments.rei create mode 100644 formatTest/typeCheckedTests/input/reasonLineComments.re create mode 100644 formatTest/typeCheckedTests/input/reasonLineComments.rei diff --git a/formatTest/typeCheckedTests/expected_output/reasonLineComments.re b/formatTest/typeCheckedTests/expected_output/reasonLineComments.re new file mode 100644 index 000000000..c48c1c429 --- /dev/null +++ b/formatTest/typeCheckedTests/expected_output/reasonLineComments.re @@ -0,0 +1,734 @@ +3; // - + +3; //- + +3; //- + +3 /*-*/; + +// **** comment + +/*** comment */ +/** docstring */ +// comment +/** docstring */ +/*** comment */ +/**** comment */ +/***** comment */ +/** */ +/*** */ +/**** */ +/**/ +/***/ +/****/ +/** (** comment *) */ +/** (*** comment *) */ +// (** comment *) +// (*** comment *) +// *(*** comment *) +// comment * +// comment ** +// comment *** +// comment **** +/** + * Multiline + */ +/** Multiline + * + */ +/** + ** + */ +module JustString = { + include Map.Make(Int32); // Comment eol include +}; + +let testingEndOfLineComments = [ + "Item 1" /* Comment For First Item */, + "Item 2" /* Comment For Second Item */, + "Item 3" /* Comment For Third Item */, + "Item 4" /* Comment For Fourth Item - but before trailing comma */, + // Comment after last item in list. +] /* Comment after rbracket */; + +// But if you place them after the comma at eol, they're preserved as such +let testingEndOfLineComments = [ + "Item 1", // Comment For First Item + "Item 2", // Comment For Second Item + "Item 3", // Comment For Third Item + "Item 4" /* Comment For Fourth Item - but before trailing comma */, + // Comment after last item in list. +] /* Comment after rbracket */; + +// The space between ; and comment shoudn't matter +let testPlacementOfTrailingComment = [ + "Item 0" // + // Comment after last item in list. +]; // Comment after semi + +// The space between ; and comment shoudn't matter +let testPlacementOfTrailingComment = [ + "Item 0" // + // Comment after last item in list. +]; // Comment after semi + +// Try again but without other things in the list +let testPlacementOfTrailingComment = [ + "Item 0" // +]; // Comment after semi + +// The space between ; and comment shoudn't matter +let testPlacementOfTrailingComment = [ + "Item 0" // + // Comment after last item in list. +]; // Comment after semi + +let testingEndOfLineComments = []; // Comment after entire let binding + +// The following is not yet idempotent +// let myFunction +// withFirstArg // First arg +// andSecondArg => { // Second Arg +// withFirstArg + andSecondArg /* before semi */ ; +// }; +let myFunction = // First arg + ( + withFirstArg, + // Second Arg + andSecondArg, + ) => + withFirstArg + andSecondArg; // After Semi + +type point = { + x: string, // x field + y: string // y field +}; + +type pointWithManyKindsOfComments = { + // Line before x + x: string, // x field + // Line before y + y: string // y field + // Final row of record +}; + +type typeParamPointWithComments('a) = { + // Line before x + x: 'a, // x field + // Line before y + y: 'a // y field + // Final row of record +}; + +// Now, interleaving comments in type params +// Type name +type typeParamPointWithComments2 + // The a type param + ( + 'a, + // The b type apram + 'b, + ) = { + // Line before x + x: 'a, // x field + // Line before y + y: 'a // y field + // Final row of record +}; + +/* The way the last row comment is formatted is suboptimal becuase + * record type definitions do not include enough location information */ +type anotherpoint = { + x: string, // x field + y: string // y field + // comment as last row of record +}; + +type t = (int, int); // End of line on t + +type t2 = (int, int); // End of line on (int, int) + +type t3 = (int, int); // End of line on (int, int) + +type variant = + | X(int, int) // End of line on X + | Y(int, int); // End of line on Y // Comment on entire type def for variant + +// Before let +let res = + // Before switch + switch (X(2, 3)) { + // Above X line + | X(_) => "result of X" // End of arrow and X line + // Above Y line + | Y(_) => "result of Y" // End of arrow and Y line + }; // After final semi in switch + +let res = + switch (X(2, 3)) { + | X(0, 0) => + // After X arrow + "result of X" // End of X body line + | X(1, 0) /* Before X's arrow */ => "result of X" // End of X body line + | X(_) => + // After X _ arrow + "result of X" // End of X body line + // Above Y line + | Y(_) => + // Comment above Y body + "result of Y" + }; + +type variant2 = + // Comment above X + | X(int, int) // End of line on X + // Comment above Y + | Y(int, int); + +type variant3 = + // Comment above X + | X(int, int) // End of line on X + // Comment above Y + | Y(int, int); // End of line on Y + +type x = { + // not attached *above* x + fieldOne: int, + fieldA: int, +} // Attached end of line after x +and y = { + // not attached *above* y + fieldTwo: int, +}; // Attached end of line after y + +type x2 = { + // not attached *above* x2 + fieldOne: int, + fieldA: int, +} // Attached end of line after x2 +and y2 = { + // not attached *above* y2 + fieldTwo: int, +}; + +let result = + switch (None) { + | Some({fieldOne: 20, fieldA: a}) => + // Where does this comment go? + let tmp = 0; + 2 + tmp; + | Some({fieldOne: n, fieldA: a}) => + // How about this one + let tmp = n; + n + tmp; + | None => 20 + }; + +let res = + // Before switch + switch (X(2, 3)) { + // Above X line + | X(_) => "result of X" // End of arrow and X line + // Above Y line + | Y(_) => "result of Y" // End of arrow and Y line + }; + +/* + * Now these end of line comments *should* be retained. + */ +let result = + switch (None) { + | Some({ + fieldOne: 20, // end of line + fieldA: a // end of line + }) => + let tmp = 0; + 2 + tmp; + | Some({ + fieldOne: n, // end of line + fieldA: a // end of line + }) => + let tmp = n; + n + tmp; + | None => 20 + }; + +/* + * These end of line comments *should* be retained. + * To get the simple expression eol comment to be retained, we just need to + * implement label breaking eol behavior much like we did with sequences. + * Otherwise, right now they are not idempotent. + */ +let res = + switch ( + // Retain this + X( + 2, + 3, + ) + ) { + // Above X line + | X( + _, // retain this + _ // retain this + ) => "result of X" + // Above Y line + | Y(_) => "result of Y" // End of arrow and Y line + }; + +type optionalTuple = + | OptTup( + option( + ( + int, // First int + int // Second int + ), + ), + ); + +type optionTuple = + option( + ( + int, // First int + int // Second int + ), + ); + +type intPair = ( + int, // First int + int // Second int +); + +type intPair2 = ( + // First int + int, + // Second int + int, +); + +let result = /**/ (2 + 3); + +// This is not yet idempotent +// { +// /**/ +// (+) 2 3 +// }; +let a = (); + +for (i in 0 to 10) { + // bla + a; +}; + +if (true) { + // hello + () +}; + +type color = + | Red(int) // After red end of line + | Black(int) // After black end of line + | Green(int); // After green end of line // On next line after color type def + +let blahCurriedX = x => + fun + | Red(10) + | Black(20) + | Green(10) => 1 // After or pattern green + | Red(x) => 0 // After red + | Black(x) => 0 // After black + | Green(x) => 0; // After second green // On next line after blahCurriedX def + +let name_equal = (x, y) => x == y; + +let equal = (i1, i2) => + i1.contents === i2.contents && true; // most unlikely first + +let equal = (i1, i2) => + compare(compare(0, 0), compare(1, 1)); // END OF LINE HERE + +let tuple_equal = ((i1, i2)) => i1 == i2; + +let tuple_equal = ((csu, mgd)) => + // Some really long comments, see https://github.com/facebook/reason/issues/811 + tuple_equal((csu, mgd)); + +/** Comments inside empty function bodies + * See https://github.com/facebook/reason/issues/860 + */ +let fun_def_comment_inline = () => {/* */}; + +let fun_def_comment_newline = () => { + // +}; + +let fun_def_comment_long = () => { + /* longer comment inside empty function body */ +}; + +let trueThing = true; + +for (i in 0 to 1) { + // comment + print_newline(); +}; + +while (trueThing) { + // comment + print_newline(); +}; + +if (trueThing) { + // comment + print_newline(); +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +} else { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment after final print +} else { + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); + // Comment after final print +}; + +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +} else { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment before print +} else { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); // eol + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); // eol + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +let f = (a, b, c, d) => a + b + c + d; + +while (trueThing) { + f( + // a + 1, + // b + 2, + // c + 3, + // d + 4, + // does work + ); +}; + +while (trueThing) { + f( + // a + 1, + // b + 2, + // c + 3, + // d + 4 // does work + ); +}; + +ignore( + ( + _really, + _long, + _printWidth, + _exceeded, + _here, + ) => { + // First comment + let x = 0; + x + x; + // Closing comment +}); + +ignore((_xxx, _yyy) => { + // First comment + let x = 0; + x + x; + // Closing comment +}); + +type tester('a, 'b) = + | TwoArgsConstructor('a, 'b) + | OneTupleArgConstructor(('a, 'b)); + +let callFunctionTwoArgs = (a, b) => (); + +let callFunctionOneTuple = tuple => (); + +let y = + TwoArgsConstructor( + 1, //eol1 + 2 // eol2 + ); + +let y = + callFunctionTwoArgs( + 1, //eol1 + 2 // eol2 + ); + +let y = + OneTupleArgConstructor(( + 1, //eol1 + 2 // eol2 + )); + +let y = + callFunctionOneTuple(( + 1, //eol1 + 2 // eol2 + )); + +type polyRecord('a, 'b) = { + fieldOne: 'a, + fieldTwo: 'b, +}; + +let r = { + fieldOne: 1, //eol1 + fieldTwo: 2 // eol2 +}; + +let r = { + fieldOne: 1, //eol1 + fieldTwo: 2 // eol2 with trailing comma +}; + +let y = + TwoArgsConstructor( + "1", //eol1 + "2" // eol2 + ); + +let y = + callFunctionTwoArgs( + "1", //eol1 + "2" // eol2 + ); + +let y = + OneTupleArgConstructor(( + "1", //eol1 + "2" // eol2 + )); + +let y = + callFunctionOneTuple(( + "1", //eol1 + "2" // eol2 + )); + +let r = { + fieldOne: "1", //eol1 + fieldTwo: "2" // eol2 +}; + +let r = { + fieldOne: "1", //eol1 + fieldTwo: "2" // eol2 with trailing comma +}; + +let identifier = "hello"; + +let y = + TwoArgsConstructor( + identifier, //eol1 + identifier // eol2 + ); + +let y = + callFunctionTwoArgs( + identifier, //eol1 + identifier // eol2 + ); + +let y = + OneTupleArgConstructor(( + identifier, //eol1 + identifier // eol2 + )); + +let y = + callFunctionOneTuple(( + identifier, //eol1 + identifier // eol2 + )); + +let r = { + fieldOne: identifier, //eol1 + fieldTwo: identifier // eol2 +}; + +let r = { + fieldOne: identifier, //eol1 + fieldTwo: identifier // eol2 with trailing comma +}; + +let y = + TwoArgsConstructor( + identifier: string, //eol1 + identifier: string // eol2 + ); + +let y = + callFunctionTwoArgs( + identifier: string, //eol1 + identifier: string // eol2 + ); + +let y = + OneTupleArgConstructor(( + identifier: string, //eol1 + identifier: string // eol2 + )); + +let y = + callFunctionOneTuple(( + identifier: string, //eol1 + identifier: string // eol2 + )); + +let r = { + fieldOne: (identifier: string), //eol1 + fieldTwo: (identifier: string) // eol2 +}; + +let r = { + fieldOne: (identifier: string), //eol1 + fieldTwo: (identifier: string) // eol2 with trailing comma +}; diff --git a/formatTest/typeCheckedTests/expected_output/reasonLineComments.rei b/formatTest/typeCheckedTests/expected_output/reasonLineComments.rei new file mode 100644 index 000000000..c76133bf9 --- /dev/null +++ b/formatTest/typeCheckedTests/expected_output/reasonLineComments.rei @@ -0,0 +1,3 @@ +module JustString: { + include Map.S; // Comment eol include +}; diff --git a/formatTest/typeCheckedTests/input/reasonLineComments.re b/formatTest/typeCheckedTests/input/reasonLineComments.re new file mode 100644 index 000000000..4bca11833 --- /dev/null +++ b/formatTest/typeCheckedTests/input/reasonLineComments.re @@ -0,0 +1,713 @@ +3; // - +3 //- +; +3//- +; +3/*-*/; +// **** comment +/*** comment */ +/** docstring */ +// comment +/** docstring */ +/*** comment */ +/**** comment */ +/***** comment */ +/** */ +/*** */ +/**** */ +/**/ +/***/ +/****/ +/** (** comment *) */ +/** (*** comment *) */ +// (** comment *) +// (*** comment *) +// *(*** comment *) +// comment * +// comment ** +// comment *** +// comment **** +/** + * Multiline + */ +/** Multiline + * + */ +/** + ** + */ + +module JustString = { + include Map.Make(Int32); // Comment eol include +}; + +let testingEndOfLineComments = + [ + "Item 1" /* Comment For First Item */, + "Item 2" /* Comment For Second Item */, + "Item 3" /* Comment For Third Item */, + "Item 4" /* Comment For Fourth Item - but before trailing comma */, + // Comment after last item in list. + ] /* Comment after rbracket */; + +// But if you place them after the comma at eol, they're preserved as such +let testingEndOfLineComments = + [ + "Item 1", // Comment For First Item + "Item 2", // Comment For Second Item + "Item 3", // Comment For Third Item + "Item 4" /* Comment For Fourth Item - but before trailing comma */, + // Comment after last item in list. + ] /* Comment after rbracket */ ; + + +// The space between ; and comment shoudn't matter +let testPlacementOfTrailingComment = [ + "Item 0" // + // Comment after last item in list. +]; // Comment after semi + +// The space between ; and comment shoudn't matter +let testPlacementOfTrailingComment = [ + "Item 0" // + // Comment after last item in list. +];// Comment after semi + +// Try again but without other things in the list +let testPlacementOfTrailingComment = [ + "Item 0" // +]; // Comment after semi + +// The space between ; and comment shoudn't matter +let testPlacementOfTrailingComment = [ + "Item 0" // + // Comment after last item in list. +];// Comment after semi + +let testingEndOfLineComments = [];// Comment after entire let binding + + +// The following is not yet idempotent +// let myFunction +// withFirstArg // First arg +// andSecondArg => { // Second Arg +// withFirstArg + andSecondArg /* before semi */ ; +// }; + +let myFunction + (// First arg + withFirstArg, + // Second Arg + andSecondArg) { + withFirstArg + andSecondArg +}; // After Semi + +type point = { + x: string, // x field + y: string, // y field +}; + +type pointWithManyKindsOfComments = { + // Line before x + x: string, // x field + // Line before y + y: string, // y field + // Final row of record +}; + +type typeParamPointWithComments('a) = { + // Line before x + x: 'a, // x field + // Line before y + y: 'a // y field + // Final row of record +}; + +// Now, interleaving comments in type params +type + // Type name + typeParamPointWithComments2( + // The a type param + 'a, + // The b type apram + 'b) = { + // Line before x + x: 'a, // x field + // Line before y + y: 'a // y field + // Final row of record +}; + +/* The way the last row comment is formatted is suboptimal becuase + * record type definitions do not include enough location information */ +type anotherpoint = { + x: string, // x field + y: string, // y field + // comment as last row of record +}; + +type t = (int, int); // End of line on t +type t2 = + (int, int) // End of line on (int, int) + ; + +type t3 = + (int, int); // End of line on (int, int) + + +type variant = + | X (int, int) // End of line on X + | Y (int, int) // End of line on Y +; // Comment on entire type def for variant + +// Before let +let res = + // Before switch + switch (X (2, 3)) { + // Above X line + | X(_) => "result of X" // End of arrow and X line + // Above Y line + | Y(_) => "result of Y" // End of arrow and Y line + }; // After final semi in switch + +let res = + switch (X (2, 3)) { + | X (0, 0) => // After X arrow + "result of X" // End of X body line + | X (1, 0) /* Before X's arrow */ => + "result of X" // End of X body line + | X (_) => // After X _ arrow + "result of X" // End of X body line + // Above Y line + | Y (_) => + // Comment above Y body + "result of Y" + }; + +type variant2 = + // Comment above X + | X (int, int) // End of line on X + // Comment above Y + | Y (int, int); + +type variant3 = + // Comment above X + | X (int, int) // End of line on X + // Comment above Y + | Y (int, int) // End of line on Y +; + + +type x = { // not attached *above* x + fieldOne : int, + fieldA : int +} // Attached end of line after x +and y = { // not attached *above* y + fieldTwo : int +} // Attached end of line after y +; + +type x2 = { // not attached *above* x2 + fieldOne : int, + fieldA : int +} // Attached end of line after x2 +and y2 = { // not attached *above* y2 + fieldTwo : int +}; + + +let result = + switch (None) { + | Some({fieldOne: 20, fieldA:a})=> // Where does this comment go? + let tmp = 0; + 2 + tmp + | Some {fieldOne: n, fieldA:a} => + // How about this one + let tmp = n; + n + tmp + | None => 20 + }; + +let res = + // Before switch + switch (X (2, 3)) { + // Above X line + | X(_) => "result of X" // End of arrow and X line + // Above Y line + | Y(_) => "result of Y" // End of arrow and Y line + }; + +/* + * Now these end of line comments *should* be retained. + */ +let result = switch (None) { + | Some { + fieldOne: 20, // end of line + fieldA:a // end of line + } => + let tmp = 0; + 2 + tmp + | Some { + fieldOne: n, // end of line + fieldA:a // end of line + } => + let tmp = n; + n + tmp + | None => 20 + }; + +/* + * These end of line comments *should* be retained. + * To get the simple expression eol comment to be retained, we just need to + * implement label breaking eol behavior much like we did with sequences. + * Otherwise, right now they are not idempotent. + */ +let res = + switch ( // Retain this + X (2, 3) + ) + { + // Above X line + | X ( + _, // retain this + _ // retain this + ) => "result of X" + + // Above Y line + | Y(_) => "result of Y" // End of arrow and Y line + }; + + +type optionalTuple = + | OptTup ( + option (( + int, // First int + int // Second int + )) + ); + +type optionTuple = + option (( + int, // First int + int // Second int + )); + +type intPair = ( + int, // First int + int // Second int +); +type intPair2 = ( + // First int + int, + // Second int + int +); + +let result = { + /**/ + (+)(2,3) +}; + +// This is not yet idempotent +// { +// /**/ +// (+) 2 3 +// }; + +let a = (); +for (i in 0 to 10) { + // bla + a +}; + +if (true) { + // hello + () +}; + +type color = + | Red(int) // After red end of line + | Black(int) // After black end of line + | Green(int) // After green end of line +; // On next line after color type def + +let blahCurriedX(x) = + fun + | Red(10) + | Black(20) + | Green(10) => 1 // After or pattern green + | Red(x) => 0 // After red + | Black(x) => 0 // After black + | Green(x) => 0 // After second green +; // On next line after blahCurriedX def + +let name_equal(x,y) { x == y }; + +let equal(i1,i2) = + i1.contents === i2.contents && true; // most unlikely first + +let equal(i1,i2) = + compare(compare(0,0),compare(1,1)); // END OF LINE HERE + +let tuple_equal((i1, i2)) = i1 == i2; + +let tuple_equal((csu, mgd)) = + // Some really long comments, see https://github.com/facebook/reason/issues/811 + tuple_equal((csu, mgd)); + +/** Comments inside empty function bodies + * See https://github.com/facebook/reason/issues/860 + */ +let fun_def_comment_inline = () => { /* */ }; + +let fun_def_comment_newline = () => { + // +}; + +let fun_def_comment_long = () => { /* longer comment inside empty function body */}; + + +let trueThing = true; + +for (i in 0 to 1) { + // comment + print_newline(); +}; + +while (trueThing) { + // comment + print_newline(); +}; + +if (trueThing) { + // comment + print_newline() +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +} else { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); + // Comment after final print +} else { + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); + // Comment before print + print_newline(); + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); + // Comment after final print +}; + + + +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +} else { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before if test +if (trueThing) { + // Comment before print + print_newline(); // eol print + // Comment before print +} else { + // Comment before print + print_newline(); // eol print + // Comment before print + print_newline(); // eol print + // Comment after print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); // eol + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +// Comment before while test +while (trueThing) { + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); // eol + // Comment before print + print_newline(); // eol + // Comment after final print +}; + +// Comment before for test +for (i in 0 to 100) { + // Comment before print + print_newline(); // eol + // Comment after final print +}; + + +let f = (a, b, c, d) => a + b + c + d; + +while(trueThing) { + f( + // a + 1, + // b + 2, + // c + 3, + // d + 4 + // does work + ); +}; +while(trueThing) { + f( + // a + 1, + // b + 2, + // c + 3, + // d + 4 // does work + ); +}; + +ignore((_really, _long, _printWidth, _exceeded, _here) => { + // First comment + let x = 0; + x + x; + // Closing comment +}); + +ignore((_xxx, _yyy) => { + // First comment + let x = 0; + x + x; + // Closing comment +}); + +type tester('a, 'b) = | TwoArgsConstructor('a, 'b) | OneTupleArgConstructor(('a, 'b)); +let callFunctionTwoArgs = (a, b) => (); +let callFunctionOneTuple = (tuple) => (); + +let y = TwoArgsConstructor( + 1, //eol1 + 2 // eol2 +); + +let y = callFunctionTwoArgs( + 1, //eol1 + 2 // eol2 +); + +let y = OneTupleArgConstructor(( + 1, //eol1 + 2 // eol2 +)); + +let y = callFunctionOneTuple(( + 1, //eol1 + 2 // eol2 +)); + + +type polyRecord('a, 'b) = {fieldOne: 'a, fieldTwo: 'b}; + +let r = { + fieldOne: 1, //eol1 + fieldTwo: 2 // eol2 +}; + +let r = { + fieldOne: 1, //eol1 + fieldTwo: 2, // eol2 with trailing comma +}; + + +let y = TwoArgsConstructor( + "1", //eol1 + "2" // eol2 +); + +let y = callFunctionTwoArgs( + "1", //eol1 + "2" // eol2 +); + +let y = OneTupleArgConstructor(( + "1", //eol1 + "2" // eol2 +)); + +let y = callFunctionOneTuple(( + "1", //eol1 + "2" // eol2 +)); + + +let r = { + fieldOne: "1", //eol1 + fieldTwo: "2" // eol2 +}; + +let r = { + fieldOne: "1", //eol1 + fieldTwo: "2", // eol2 with trailing comma +}; + +let identifier = "hello"; + +let y = TwoArgsConstructor( + identifier, //eol1 + identifier // eol2 +); + +let y = callFunctionTwoArgs( + identifier , //eol1 + identifier // eol2 +); + +let y = OneTupleArgConstructor(( + identifier , //eol1 + identifier // eol2 +)); + +let y = callFunctionOneTuple(( + identifier , //eol1 + identifier // eol2 +)); + + +let r = { + fieldOne: identifier, //eol1 + fieldTwo: identifier // eol2 +}; + +let r = { + fieldOne: identifier, //eol1 + fieldTwo: identifier, // eol2 with trailing comma +}; + + +let y = TwoArgsConstructor( + identifier : string, //eol1 + identifier : string// eol2 +); + +let y = callFunctionTwoArgs( + identifier : string , //eol1 + identifier : string // eol2 +); + +let y = OneTupleArgConstructor(( + identifier : string , //eol1 + identifier : string // eol2 +)); + +let y = callFunctionOneTuple(( + identifier : string , //eol1 + identifier : string // eol2 +)); + + +let r = { + fieldOne: (identifier : string), //eol1 + fieldTwo: (identifier : string) // eol2 +}; + +let r = { + fieldOne: (identifier : string), //eol1 + fieldTwo: (identifier : string), // eol2 with trailing comma +}; diff --git a/formatTest/typeCheckedTests/input/reasonLineComments.rei b/formatTest/typeCheckedTests/input/reasonLineComments.rei new file mode 100644 index 000000000..087516744 --- /dev/null +++ b/formatTest/typeCheckedTests/input/reasonLineComments.rei @@ -0,0 +1,3 @@ +module JustString : { + include Map.S; // Comment eol include +}; diff --git a/src/reason-parser/reason_comment.ml b/src/reason-parser/reason_comment.ml index acc6aca23..17230badc 100644 --- a/src/reason-parser/reason_comment.ml +++ b/src/reason-parser/reason_comment.ml @@ -86,7 +86,7 @@ let wrap t = match t.text with | "" | "*" -> "/***/" | txt when Syntax_util.is_line_comment txt -> - "//" ^ (String.sub txt 0 (String.length txt - 1)) + "//" ^ txt | txt when txt.[0] = '*' && txt.[1] <> '*' -> align_lines ("/**" ^ txt ^ "*/") | txt -> align_lines ("/*" ^ txt ^ "*/") diff --git a/src/reason-parser/vendor/easy_format/easy_format.ml b/src/reason-parser/vendor/easy_format/easy_format.ml index 9a49f52c9..37ef3dadc 100644 --- a/src/reason-parser/vendor/easy_format/easy_format.ml +++ b/src/reason-parser/vendor/easy_format/easy_format.ml @@ -93,6 +93,7 @@ type escape = type styles = (style_name * style) list let pp_print_multiline ppf str = + let last = String.length str - 1 in let rec loop i = match String.index_from str i '\n' with | exception Not_found -> @@ -110,6 +111,12 @@ let pp_print_multiline ppf str = (Format.pp_get_margin ppf () + String.length str) (String.sub str i (String.length str - i)); pp_close_box ppf () + | j when j = last -> + (* Same lie but for single line comments *) + pp_print_as ppf + (Format.pp_get_margin ppf () + String.length str) + (String.sub str i (j - i)); + pp_close_box ppf () | j -> pp_print_string ppf (String.sub str i (j - i)); pp_force_newline ppf ();