Parser: Update OBLOCKSEP token passing

src/Compiler/Checking/CheckRecordSyntaxHelpers.fs

@@ -90,14 +90,24 @@ let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid
         let totalRange (origId: Ident) (id: Ident) =
             withStartEnd origId.idRange.End id.idRange.Start origId.idRange
 
-        match withExpr with
-        | SynExpr.Ident origId, (blockSep: BlockSeparator) ->
-            let lid, rng = upToId blockSep.Range id (origId :: ids)
+        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
 
-            Some(
-                SynExpr.LongIdent(false, LongIdentWithDots(lid, rng), None, totalRange origId id),
-                BlockSeparator.Offside(blockSep.Range, None)
-            )
+        match withExpr with
+        | SynExpr.Ident origId, (blockSep: BlockSeparator option) ->
+            let mBlockSep =
+                match blockSep with
+                | Some sep -> sep.Range
+                | None -> rangeOfBlockSeparator origId
+
+            let lid, rng = upToId mBlockSep id (origId :: ids)
+            Some(SynExpr.LongIdent(false, LongIdentWithDots(lid, rng), None, totalRange origId id), blockSep)
         | _ -> None
 
     let rec synExprRecd copyInfo (outerFieldId: Ident) innerFields exprBeingAssigned =
@@ -120,7 +130,13 @@ let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid
                                AnonRecdTypeInfo.TupInfo = TupInfo.Const isStruct
                            }) ->
                 let fields = [ LongIdentWithDots([ fieldId ], []), None, nestedField ]
-                SynExpr.AnonRecd(isStruct, copyInfo outerFieldId, fields, outerFieldId.idRange, { OpeningBraceRange = range0 })
+                // Pass through optional separator for anonymous records
+                let copyInfoAnon =
+                    match copyInfo outerFieldId with
+                    | Some(exprWhenWith, sepOpt) -> Some(exprWhenWith, sepOpt)
+                    | None -> None
+
+                SynExpr.AnonRecd(isStruct, copyInfoAnon, fields, outerFieldId.idRange, { OpeningBraceRange = range0 })
             | _ ->
                 let fields =
                     [
@@ -153,7 +169,7 @@ let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid
 
 /// When the original expression in copy-and-update is more complex than `{ x with ... }`, like `{ f () with ... }`,
 /// we bind it first, so that it's not evaluated multiple times during a nested update
-let BindOriginalRecdExpr (withExpr: SynExpr * BlockSeparator) mkRecdExpr =
+let BindOriginalRecdExpr (withExpr: SynExpr * BlockSeparator option) mkRecdExpr =
     let originalExpr, blockSep = withExpr
     let mOrigExprSynth = originalExpr.Range.MakeSynthetic()
     let id = mkSynId mOrigExprSynth "bind@"

src/Compiler/Checking/CheckRecordSyntaxHelpers.fsi

@@ -16,8 +16,10 @@ val TransformAstForNestedUpdates:
     overallTy: TType ->
     lid: LongIdent ->
     exprBeingAssigned: SynExpr ->
-    withExpr: SynExpr * BlockSeparator ->
+    withExpr: SynExpr * BlockSeparator option ->
         (Ident list * Ident) * SynExpr option
 
 val BindOriginalRecdExpr:
-    withExpr: SynExpr * BlockSeparator -> mkRecdExpr: ((SynExpr * BlockSeparator) option -> SynExpr) -> SynExpr
+    withExpr: SynExpr * BlockSeparator option ->
+        mkRecdExpr: ((SynExpr * BlockSeparator option) option -> SynExpr) ->
+            SynExpr

src/Compiler/Service/ServiceParseTreeWalk.fs

@@ -400,6 +400,36 @@ module SyntaxTraversal =
                 let traverseSynType = traverseSynType path
                 let traversePat = traversePat path
 
+                let diveIntoRecordLikeExpr path (exprRange: range) (hasFields: bool) (copyOpt: (SynExpr * BlockSeparator option) option) =
+                    [
+                        match copyOpt with
+                        | Some(expr, blockSep) ->
+                            // Dive into the copy expression
+                            yield dive expr expr.Range traverseSynExpr
+
+                            // Dive into the WITH separator (if present) and handle caret-after-WITH
+                            match blockSep with
+                            | Some blockSep ->
+                                yield
+                                    dive () blockSep.Range (fun () ->
+                                        if posGeq pos blockSep.Range.End then
+                                            // { x with $ }
+                                            visitor.VisitRecordField(path, Some expr, None)
+                                        else
+                                            None)
+                            | None ->
+                                // If there is a copy-with but no explicit separator and no fields yet,
+                                // still offer field completions once the caret is after the copy expr.
+                                if not hasFields then
+                                    yield
+                                        dive () exprRange (fun () ->
+                                            if posGeq pos expr.Range.End then
+                                                visitor.VisitRecordField(path, Some expr, None)
+                                            else
+                                                None)
+                        | None -> ()
+                    ]
+
                 match e with
                 | SynExpr.LongIdentSet(expr = synExpr)
                 | SynExpr.DotGet(expr = synExpr)
@@ -444,19 +474,7 @@ module SyntaxTraversal =
 
                 | SynExpr.AnonRecd(copyInfo = copyOpt; recordFields = fields) ->
                     [
-                        match copyOpt with
-                        | Some(expr, blockSep) ->
-                            yield dive expr expr.Range traverseSynExpr
-
-                            yield
-                                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)
-                                    else
-                                        None)
-                        | _ -> ()
+                        yield! diveIntoRecordLikeExpr path expr.Range (not (List.isEmpty fields)) copyOpt
 
                         for field, _, x in fields do
                             yield dive () field.Range (fun () -> visitor.VisitRecordField(path, copyOpt |> Option.map fst, Some field))
@@ -466,19 +484,11 @@ module SyntaxTraversal =
 
                 | SynExpr.Record(baseInfo = inheritOpt; copyInfo = copyOpt; recordFields = fields) ->
                     [
-                        let diveIntoSeparator offsideColumn scPosOpt copyOpt =
-                            match scPosOpt with
-                            | Some scPos ->
-                                if posGeq pos scPos then
-                                    visitor.VisitRecordField(path, copyOpt, None) // empty field after the inherits
-                                else
-                                    None
-                            | None ->
-                                //semicolon position is not available - use offside rule
-                                if pos.Column = offsideColumn then
-                                    visitor.VisitRecordField(path, copyOpt, None) // empty field after the inherits
-                                else
-                                    None
+                        let diveIntoSeparator scPos copyOpt =
+                            if posGeq pos scPos then
+                                visitor.VisitRecordField(path, copyOpt, None) // empty field after the inherits
+                            else
+                                None
 
                         match inheritOpt with
                         | Some(_ty, expr, _range, sepOpt, inheritRange) ->
@@ -505,23 +515,11 @@ module SyntaxTraversal =
                                         // inherit A()
                                         // $
                                         // field1 = 5
-                                        diveIntoSeparator inheritRange.StartColumn blockSep.Position None)
+                                        diveIntoSeparator blockSep.Range.End None)
                             | None -> ()
                         | _ -> ()
 
-                        match copyOpt with
-                        | Some(expr, blockSep) ->
-                            yield dive expr expr.Range traverseSynExpr
-
-                            yield
-                                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)
-                                    else
-                                        None)
-                        | _ -> ()
+                        yield! diveIntoRecordLikeExpr path expr.Range (not (List.isEmpty fields)) copyOpt
 
                         let copyOpt = Option.map fst copyOpt
 
@@ -563,7 +561,7 @@ module SyntaxTraversal =
                                         // field1 = 5
                                         // $
                                         // field2 = 5
-                                        diveIntoSeparator offsideColumn blockSep.Position copyOpt)
+                                        diveIntoSeparator blockSep.Range.End copyOpt)
                             | _ -> ()
 
                     ]

src/Compiler/SyntaxTree/SyntaxTree.fs

@@ -308,21 +308,13 @@ type SeqExprOnly = SeqExprOnly of bool
 
 [<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
+    | Semicolon of range: range
+    | Comma of range: range
 
     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
+        | Comma(range = m) -> m
 
 type RecordFieldName = SynLongIdent * bool
 
@@ -549,7 +541,7 @@ type SynExpr =
 
     | AnonRecd of
         isStruct: bool *
-        copyInfo: (SynExpr * BlockSeparator) option *
+        copyInfo: (SynExpr * BlockSeparator option) option *
         recordFields: (SynLongIdent * range option * SynExpr) list *
         range: range *
         trivia: SynExprAnonRecdTrivia
@@ -558,7 +550,7 @@ type SynExpr =
 
     | Record of
         baseInfo: (SynType * SynExpr * range * BlockSeparator option * range) option *
-        copyInfo: (SynExpr * BlockSeparator) option *
+        copyInfo: (SynExpr * BlockSeparator option) option *
         recordFields: SynExprRecordField list *
         range: range
 

src/Compiler/SyntaxTree/SyntaxTree.fsi

@@ -359,22 +359,13 @@ type SeqExprOnly =
 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
+    | Semicolon of range: range
     /// 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
+    | Comma of range: range
 
     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.
 type RecordFieldName = SynLongIdent * bool
@@ -607,7 +598,7 @@ type SynExpr =
     /// F# syntax: struct {| id1=e1; ...; idN=eN |}
     | AnonRecd of
         isStruct: bool *
-        copyInfo: (SynExpr * BlockSeparator) option *
+        copyInfo: (SynExpr * BlockSeparator option) option *
         recordFields: (SynLongIdent * range option * SynExpr) list *
         range: range *
         trivia: SynExprAnonRecdTrivia
@@ -621,7 +612,7 @@ type SynExpr =
     /// every field includes range of separator after the field (for tooling)
     | Record of
         baseInfo: (SynType * SynExpr * range * BlockSeparator option * range) option *
-        copyInfo: (SynExpr * BlockSeparator) option *
+        copyInfo: (SynExpr * BlockSeparator option) option *
         recordFields: SynExprRecordField list *
         range: range
 

src/Compiler/pars.fsy

@@ -3668,14 +3668,15 @@ namePatPairs:
      { let (id: Ident), mEq, (pat: SynPat) = $1
        let m = unionRanges id.idRange pat.Range
        let lid = SynLongIdent([id], [], [None])
-       NamePatPairField(lid, mEq, m, pat, Some $2) :: $3 }
+       NamePatPairField(lid, mEq, m, pat, $2) :: $3 }
 
    | namePatPair seps_block seps_block namePatPairs
-      { reportParseErrorAt (rhs parseState 3) (FSComp.SR.parsExpectingPattern ())
+      { let mSep = match $3 with | Some sep -> sep.Range | None -> rhs parseState 3
+        reportParseErrorAt mSep (FSComp.SR.parsExpectingPattern ())
         let (id: Ident), mEq, (pat: SynPat) = $1
         let m = unionRanges id.idRange pat.Range
         let lid = SynLongIdent([id], [], [None])
-        NamePatPairField(lid, mEq, m, pat, Some $2) :: $4 }
+        NamePatPairField(lid, mEq, m, pat, $2) :: $4 }
 
 namePatPair:
    | ident EQUALS parenPattern
@@ -4016,13 +4017,13 @@ recordPatternElementsAux:
   | recordPatternElement seps_block recordPatternElementsAux
       { let (lid: SynLongIdent), mEq, (pat: SynPat) = $1
         let m = unionRanges lid.Range pat.Range
-        NamePatPairField(lid, mEq, m, pat, Some $2) :: $3 }
+        NamePatPairField(lid, mEq, m, pat, $2) :: $3 }
 
   | recordPatternElement seps_block seps_block recordPatternElementsAux
       { reportParseErrorAt (rhs parseState 3) (FSComp.SR.parsExpectingPattern ())
         let (lid: SynLongIdent), mEq, (pat: SynPat) = $1
         let m = unionRanges lid.Range pat.Range
-        NamePatPairField(lid, mEq, m, pat, Some $2) :: $4 }
+        NamePatPairField(lid, mEq, m, pat, $2) :: $4 }
 
 recordPatternElement:
   | path EQUALS parenPattern
@@ -5709,7 +5710,7 @@ recdExprCore:
   | appExpr
     { let mExpr = rhs parseState 1
       reportParseErrorAt mExpr (FSComp.SR.parsFieldBinding ())
-      Some($1, BlockSeparator.Offside(mExpr.EndRange, None)), [] }
+      (Some($1, None), []) }
 
 /*
     handles cases when identifier can start from the underscore
@@ -5743,36 +5744,42 @@ recdExprCore:
   | appExpr WITH recdBinding recdExprBindings opt_seps_block
      { let l = List.rev $4
        let l = rebindRanges $3 l $5
-       (Some($1, BlockSeparator.Offside(rhs parseState 2, None)), l) }
+       (Some($1, None), l) }
 
   | appExpr OWITH opt_seps_block OEND
-     { (Some($1, BlockSeparator.Offside(rhs parseState 2, None)), []) }
+     { (Some($1, None), []) }
 
   | appExpr OWITH recdBinding recdExprBindings opt_seps_block OEND
      { let l = List.rev $4
        let l = rebindRanges $3 l $5
-       (Some($1, BlockSeparator.Offside(rhs parseState 2, None)), l) }
+       (Some($1, None), l) }
 
 opt_seps_block:
   | seps_block
-     { Some $1 }
+     { $1 }
 
   | /* EMPTY */
      { None }
 
 seps_block:
   | OBLOCKSEP
-     { BlockSeparator.Offside((rhs parseState 1), None) }
+     { 
+       // OBLOCKSEP is purely syntactic: do not produce a BlockSeparator value
+       // Treat it as absence of an explicit separator
+       None
+     }
 
   | SEMICOLON
      { let m = (rhs parseState 1)
-       BlockSeparator.Semicolon(m, Some m.End) }
+       Some (BlockSeparator.Semicolon(m)) }
 
   | SEMICOLON OBLOCKSEP
-     { BlockSeparator.Semicolon((rhs2 parseState 1 2), Some (rhs parseState 1).End) }
+     { let mSemi = (rhs parseState 1)
+       Some (BlockSeparator.Semicolon(mSemi)) }
 
   | OBLOCKSEP SEMICOLON
-     { BlockSeparator.Semicolon((rhs2 parseState 1 2), Some (rhs parseState 2).End) }
+     { let mSemi = (rhs parseState 2)
+       Some (BlockSeparator.Semicolon(mSemi)) }
 
 
 /* identifier can start from the underscore */
@@ -5787,7 +5794,7 @@ pathOrUnderscore :
 
 recdExprBindings:
   | recdExprBindings seps_block recdBinding
-     { ($3, Some $2) :: $1 }
+     { ($3, $2) :: $1 }
 
   | /* EMPTY */
      { [] }