Enforce strict multiline literal shapes and single-line inline record annotations

Author: pchalamet

docs/syntax-and-indentation.md

@@ -36,6 +36,7 @@ This document describes the concrete syntax accepted by the interpreter and the
   - union case patterns in cases: `Case` and `Case pattern`
 - Records:
   - literal `{ Name = "a"; Age = 1 }`
+  - if fields start on the next line, `{` must be on its own line
   - multiline example:
   ```fsharp
   {
@@ -52,6 +53,7 @@ This document describes the concrete syntax accepted by the interpreter and the
   - record entries use field assignments (`Field = value`)
   - when braces are empty (`{}`), the literal is a map
   - keys are bracketed expressions (`[expr]`) and must infer to `string`
+  - if entries start on the next line, `{` must be on its own line
   - multiline example:
   ```fsharp
   {
@@ -76,6 +78,7 @@ This document describes the concrete syntax accepted by the interpreter and the
   ```
   - range `[a..b]`
   - `::`, `@`
+  - if elements start on the next line, `[` must be on its own line
 - Tuples:
   - `(a, b, c)`
 - Options:
@@ -157,5 +160,4 @@ All of the following map literal layouts are valid:
 - Parameter annotations accept inline structural record types:
   - `let format_address (address: { City: string; Zip: int }) = ...`
   - `fun (x: { Name: string; Tags: string list }) -> ...`
-  - `let f (x: { Name: string\n    Zip: int }) = ...`
-- Inline record annotation fields can be separated by `;` or by newline in multiline form.
+- Inline record annotation fields are `;`-separated in single-line form.

samples/layout-styles.fss

@@ -2,10 +2,7 @@ type Address =
     { City: string
       Zip: int }
 
-let format_address (address: {
-    City: string
-    Zip: int
-}) =
+let format_address (address: { City: string; Zip: int }) =
     $"{address.City} ({address.Zip})"
 
 let names_compact =

src/FScript.Language/Parser.fs

@@ -5,6 +5,8 @@ module Parser =
         let mutable index = 0
         member _.Peek() = tokens.[index]
         member _.PeekAt(offset: int) = tokens.[index + offset]
+        member _.TokenAt(i: int) = tokens.[i]
+        member _.Index = index
         member _.Mark() = index
         member _.Restore(mark: int) = index <- mark
         member _.Next() =
@@ -161,6 +163,23 @@ module Parser =
                     progress <- true
             consumed
 
+        let hasNonLayoutTokenBeforeOnSameLine (tokenIndex: int) (line: int) =
+            let mutable i = tokenIndex - 1
+            let mutable keepSearching = true
+            let mutable foundSameLine = false
+            while keepSearching && i >= 0 do
+                let tok = stream.TokenAt(i)
+                match tok.Kind with
+                | Newline ->
+                    keepSearching <- false
+                | Indent
+                | Dedent ->
+                    i <- i - 1
+                | _ ->
+                    foundSameLine <- tok.Span.Start.Line = line
+                    keepSearching <- false
+            foundSameLine
+
         let mutable allowIndentedApplication = true
         let mutable allowBinaryNewlineSkipping = true
 
@@ -185,22 +204,12 @@ module Parser =
                     stream.Expect(Colon, "Expected ':' after inline record type field name") |> ignore
                     let fieldType = parseTypeRef()
                     fields.Add(fieldName, fieldType)
-                consumeLayoutSeparators() |> ignore
                 if stream.Peek().Kind = RBrace then
                     raise (ParseException { Message = "Inline record type must define at least one field"; Span = stream.Peek().Span })
                 parseField()
-                let mutable keepParsing = true
-                while keepParsing do
-                    let hasSeparator =
-                        if stream.Match(Semicolon) then
-                            consumeLayoutSeparators() |> ignore
-                            true
-                        else
-                            consumeLayoutSeparators()
-                    if hasSeparator && stream.Peek().Kind <> RBrace then
+                while stream.Match(Semicolon) do
+                    if stream.Peek().Kind <> RBrace then
                         parseField()
-                    else
-                        keepParsing <- false
                 stream.Expect(RBrace, "Expected '}' in inline record type") |> ignore
                 TRRecord (fields |> Seq.toList)
             | LParen ->
@@ -507,7 +516,12 @@ module Parser =
                         let rp = stream.Expect(RParen, "Expected ')' after expression")
                         EParen(first, mkSpanFrom lp.Span rp.Span)
             | LBracket ->
+                let lbIndex = stream.Index
                 let lb = stream.Next()
+                let immediateMultiline = stream.Peek().Kind = Newline
+                let hasSameLinePrefix = hasNonLayoutTokenBeforeOnSameLine lbIndex lb.Span.Start.Line
+                if immediateMultiline && hasSameLinePrefix then
+                    raise (ParseException { Message = "For multiline list literals, '[' must be on its own line"; Span = lb.Span })
                 consumeLayoutSeparators() |> ignore
                 if stream.Match(RBracket) then
                     EList([], mkSpanFrom lb.Span lb.Span)
@@ -537,7 +551,12 @@ module Parser =
                         let rb = stream.Expect(RBracket, "Expected ']' in list literal")
                         EList(elements |> Seq.toList, mkSpanFrom lb.Span rb.Span)
             | LBrace ->
+                let lbIndex = stream.Index
                 let lb = stream.Next()
+                let immediateMultiline = stream.Peek().Kind = Newline
+                let hasSameLinePrefix = hasNonLayoutTokenBeforeOnSameLine lbIndex lb.Span.Start.Line
+                if immediateMultiline && hasSameLinePrefix then
+                    raise (ParseException { Message = "For multiline record/map literals, '{' must be on its own line"; Span = lb.Span })
                 consumeLayoutSeparators() |> ignore
                 if stream.Match(RBrace) then
                     EMap([], mkSpanFrom lb.Span lb.Span)

tests/FScript.Language.Tests/ParserTests.fs

@@ -82,6 +82,11 @@ type ParserTests () =
         | SExpr (EList (items, _)) -> items.Length |> should equal 3
         | _ -> Assert.Fail("Expected block multiline list literal")
 
+    [<Test>]
+    member _.``Rejects multiline list literal with '[' kept on assignment line`` () =
+        let act () = Helpers.parse "let x = [\n 1\n 2\n]" |> ignore
+        act |> should throw typeof<ParseException>
+
     [<Test>]
     member _.``Parses range expressions`` () =
         let p1 = Helpers.parse "[1..5]"
@@ -130,6 +135,11 @@ type ParserTests () =
         | SExpr (ERecord (fields, _)) -> fields.Length |> should equal 2
         | _ -> Assert.Fail("Expected multiline block record literal")
 
+    [<Test>]
+    member _.``Rejects multiline record literal with '{' kept on assignment line`` () =
+        let act () = Helpers.parse "let x = {\n  Name = \"a\"\n  Age = 1\n}" |> ignore
+        act |> should throw typeof<ParseException>
+
     [<Test>]
     member _.``Parses record copy-update expression`` () =
         let p = Helpers.parse "{ p with Age = 2 }"
@@ -162,6 +172,11 @@ type ParserTests () =
             entries.Length |> should equal 2
         | _ -> Assert.Fail("Expected multiline map literal")
 
+    [<Test>]
+    member _.``Rejects multiline map literal with '{' kept on assignment line`` () =
+        let act () = Helpers.parse "let x = {\n  [\"a\"] = 1\n  [\"b\"] = 2\n}" |> ignore
+        act |> should throw typeof<ParseException>
+
     [<Test>]
     member _.``Parses compact multiline map literal`` () =
         let src = "{ [\"a\"] = 1\n  [\"b\"] = 2 }"
@@ -250,11 +265,9 @@ type ParserTests () =
         | _ -> Assert.Fail("Expected annotated let parameter with inline record type")
 
     [<Test>]
-    member _.``Parses annotated parameter with multiline inline record type`` () =
-        let p = Helpers.parse "let format_address (address: { City: string\n    Zip: int }) = address.City"
-        match p.[0] with
-        | SLet ("format_address", [ { Name = "address"; Annotation = Some (TRRecord [ ("City", TRName "string"); ("Zip", TRName "int") ]) } ], _, _, _, _) -> ()
-        | _ -> Assert.Fail("Expected annotated let parameter with multiline inline record type")
+    member _.``Rejects multiline inline record type annotation`` () =
+        let act () = Helpers.parse "let format_address (address: {\n    City: string\n    Zip: int\n}) = address.City" |> ignore
+        act |> should throw typeof<ParseException>
 
     [<Test>]
     member _.``Parses nameof expression`` () =