Parser: Capture multiple block separators (#18899)

Author: edgarfgp

docs/release-notes/.FSharp.Compiler.Service/10.0.100.md

@@ -30,6 +30,7 @@
 * Use `errorR` instead of `error` in `CheckDeclarations.fs` when possible. ([PR #18645](https://github.com/dotnet/fsharp/pull/18645))
 * Parser: Capture named fields block separators. ([PR #18857](https://github.com/dotnet/fsharp/pull/18857))
 * Type checker: use inner expr range in upcast constraints errors ([PR #18850](https://github.com/dotnet/fsharp/pull/18850))
+* Parser: Capture multiple block separators ([PR #18899](https://github.com/dotnet/fsharp/pull/18899))
 
 ### Breaking Changes
 

src/Compiler/Checking/CheckRecordSyntaxHelpers.fs

@@ -90,19 +90,14 @@ let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid
         let totalRange (origId: Ident) (id: Ident) =
             withStartEnd origId.idRange.End id.idRange.Start origId.idRange
 
-        let rangeOfBlockSeparator (id: Ident) =
-            let idEnd = id.idRange.End
-            let blockSeparatorStartCol = idEnd.Column
-            let blockSeparatorEndCol = blockSeparatorStartCol + 4
-            let blockSeparatorStartPos = mkPos idEnd.Line blockSeparatorStartCol
-            let blockSeparatorEndPos = mkPos idEnd.Line blockSeparatorEndCol
-
-            withStartEnd blockSeparatorStartPos blockSeparatorEndPos id.idRange
-
         match withExpr with
-        | SynExpr.Ident origId, (sepRange, _) ->
-            let lid, rng = upToId sepRange id (origId :: ids)
-            Some(SynExpr.LongIdent(false, LongIdentWithDots(lid, rng), None, totalRange origId id), (rangeOfBlockSeparator id, None))
+        | SynExpr.Ident origId, (blockSep: BlockSeparator) ->
+            let lid, rng = upToId blockSep.Range id (origId :: ids)
+
+            Some(
+                SynExpr.LongIdent(false, LongIdentWithDots(lid, rng), None, totalRange origId id),
+                BlockSeparator.Offside(blockSep.Range, None)
+            )
         | _ -> None
 
     let rec synExprRecd copyInfo (outerFieldId: Ident) innerFields exprBeingAssigned =

src/Compiler/Checking/CheckRecordSyntaxHelpers.fsi

@@ -10,13 +10,13 @@ open FSharp.Compiler.TypedTree
 val GroupUpdatesToNestedFields:
     fields: ((Ident list * Ident) * SynExpr option) list -> ((Ident list * Ident) * SynExpr option) list
 
-val TransformAstForNestedUpdates<'a> :
+val TransformAstForNestedUpdates:
     cenv: TcFileState ->
     env: TcEnv ->
     overallTy: TType ->
     lid: LongIdent ->
     exprBeingAssigned: SynExpr ->
-    withExpr: SynExpr * (range * 'a) ->
+    withExpr: SynExpr * BlockSeparator ->
         (Ident list * Ident) * SynExpr option
 
 val BindOriginalRecdExpr:

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -7757,7 +7757,7 @@ and TcRecdExpr cenv overallTy env tpenv (inherits, withExprOpt, synRecdFields, m
 
                 match withExprOpt, synLongId.LongIdent, exprBeingAssigned with
                 | _, [ id ], _ -> ([], id), exprBeingAssigned
-                | Some withExpr, lid, Some exprBeingAssigned -> TransformAstForNestedUpdates cenv env overallTy lid exprBeingAssigned withExpr
+                | Some (origExpr, blockSep), lid, Some exprBeingAssigned -> TransformAstForNestedUpdates cenv env overallTy lid exprBeingAssigned (origExpr, blockSep)
                 | _ -> List.frontAndBack synLongId.LongIdent, exprBeingAssigned)
 
         let flds = if hasOrigExpr then GroupUpdatesToNestedFields flds else flds

src/Compiler/Service/ServiceParseTreeWalk.fs

@@ -445,12 +445,12 @@ module SyntaxTraversal =
                 | SynExpr.AnonRecd(copyInfo = copyOpt; recordFields = fields) ->
                     [
                         match copyOpt with
-                        | Some(expr, (withRange, _)) ->
+                        | Some(expr, blockSep) ->
                             yield dive expr expr.Range traverseSynExpr
 
                             yield
-                                dive () withRange (fun () ->
-                                    if posGeq pos withRange.End then
+                                dive () blockSep.Range (fun () ->
+                                    if posGeq pos blockSep.Range.End then
                                         // special case: caret is after WITH
                                         // { x with $ }
                                         visitor.VisitRecordField(path, Some expr, None)
@@ -498,24 +498,24 @@ module SyntaxTraversal =
                                         traverseSynExpr expr)
 
                             match sepOpt with
-                            | Some(sep, scPosOpt) ->
+                            | Some blockSep ->
                                 yield
-                                    dive () sep (fun () ->
+                                    dive () blockSep.Range (fun () ->
                                         // special case: caret is below 'inherit' + one or more fields are already defined
                                         // inherit A()
                                         // $
                                         // field1 = 5
-                                        diveIntoSeparator inheritRange.StartColumn scPosOpt None)
+                                        diveIntoSeparator inheritRange.StartColumn blockSep.Position None)
                             | None -> ()
                         | _ -> ()
 
                         match copyOpt with
-                        | Some(expr, (withRange, _)) ->
+                        | Some(expr, blockSep) ->
                             yield dive expr expr.Range traverseSynExpr
 
                             yield
-                                dive () withRange (fun () ->
-                                    if posGeq pos withRange.End then
+                                dive () blockSep.Range (fun () ->
+                                    if posGeq pos blockSep.Range.End then
                                         // special case: caret is after WITH
                                         // { x with $ }
                                         visitor.VisitRecordField(path, Some expr, None)
@@ -556,14 +556,14 @@ module SyntaxTraversal =
                             | None -> ()
 
                             match sepOpt with
-                            | Some(sep, scPosOpt) ->
+                            | Some blockSep ->
                                 yield
-                                    dive () sep (fun () ->
+                                    dive () blockSep.Range (fun () ->
                                         // special case: caret is between field bindings
                                         // field1 = 5
                                         // $
                                         // field2 = 5
-                                        diveIntoSeparator offsideColumn scPosOpt copyOpt)
+                                        diveIntoSeparator offsideColumn blockSep.Position copyOpt)
                             | _ -> ()
 
                     ]

src/Compiler/SyntaxTree/SyntaxTree.fs

@@ -306,7 +306,23 @@ type DebugPointAtBinding =
 
 type SeqExprOnly = SeqExprOnly of bool
 
-type BlockSeparator = range * pos option
+[<NoEquality; NoComparison; RequireQualifiedAccess>]
+type BlockSeparator =
+    | Semicolon of range: range * position: pos option
+    | Comma of range: range * position: pos option
+    | Offside of range: range * position: pos option
+
+    member this.Range =
+        match this with
+        | Semicolon(range = m)
+        | Comma(range = m)
+        | Offside(range = m) -> m
+
+    member this.Position =
+        match this with
+        | Semicolon(position = p)
+        | Comma(position = p)
+        | Offside(position = p) -> p
 
 type RecordFieldName = SynLongIdent * bool
 

src/Compiler/SyntaxTree/SyntaxTree.fsi

@@ -354,9 +354,26 @@ type SeqExprOnly =
     /// Indicates if a for loop is 'for x in e1 -> e2', only valid in sequence expressions
     | SeqExprOnly of bool
 
-/// Represents the location of the separator block + optional position
-/// of the semicolon (used for tooling support)
-type BlockSeparator = range * pos option
+/// Represents the location of the separator block and optional position of the semicolon (used for tooling support)
+[<NoEquality; NoComparison; RequireQualifiedAccess>]
+type BlockSeparator =
+    /// A separator consisting of a semicolon ';'
+    /// range is the range of the semicolon
+    /// position is the position of the semicolon (if available)
+    | Semicolon of range: range * position: pos option
+    /// A separator consisting of a comma ','
+    /// range is the range of the comma
+    /// position is the position of the comma (if available)
+    | Comma of range: range * position: pos option
+
+    // A separator consisting of a newline
+    /// range is the range of the newline
+    /// position is the position of the newline (if available)
+    | Offside of range: range * position: pos option
+
+    member Range: range
+
+    member Position: pos option
 
 /// Represents a record field name plus a flag indicating if given record field name is syntactically
 /// correct and can be used in name resolution.

src/Compiler/pars.fsy

@@ -5709,7 +5709,7 @@ recdExprCore:
   | appExpr
     { let mExpr = rhs parseState 1
       reportParseErrorAt mExpr (FSComp.SR.parsFieldBinding ())
-      Some($1, (mExpr.EndRange, None)), [] }
+      Some($1, BlockSeparator.Offside(mExpr.EndRange, None)), [] }
 
 /*
     handles cases when identifier can start from the underscore
@@ -5743,15 +5743,15 @@ recdExprCore:
   | appExpr WITH recdBinding recdExprBindings opt_seps_block
      { let l = List.rev $4
        let l = rebindRanges $3 l $5
-       (Some($1, (rhs parseState 2, None)), l) }
+       (Some($1, BlockSeparator.Offside(rhs parseState 2, None)), l) }
 
   | appExpr OWITH opt_seps_block OEND
-     { (Some($1, (rhs parseState 2, None)), []) }
+     { (Some($1, BlockSeparator.Offside(rhs parseState 2, None)), []) }
 
   | appExpr OWITH recdBinding recdExprBindings opt_seps_block OEND
      { let l = List.rev $4
        let l = rebindRanges $3 l $5
-       (Some($1, (rhs parseState 2, None)), l) }
+       (Some($1, BlockSeparator.Offside(rhs parseState 2, None)), l) }
 
 opt_seps_block:
   | seps_block
@@ -5762,17 +5762,17 @@ opt_seps_block:
 
 seps_block:
   | OBLOCKSEP
-     { (rhs parseState 1), None }
+     { BlockSeparator.Offside((rhs parseState 1), None) }
 
   | SEMICOLON
      { let m = (rhs parseState 1)
-       m, Some m.End }
+       BlockSeparator.Semicolon(m, Some m.End) }
 
   | SEMICOLON OBLOCKSEP
-     { (rhs2 parseState 1 2), Some (rhs parseState 1).End }
+     { BlockSeparator.Semicolon((rhs2 parseState 1 2), Some (rhs parseState 1).End) }
 
   | OBLOCKSEP SEMICOLON
-     { (rhs2 parseState 1 2), Some (rhs parseState 2).End }
+     { BlockSeparator.Semicolon((rhs2 parseState 1 2), Some (rhs parseState 2).End) }
 
 
 /* identifier can start from the underscore */