Parser: Allow comma as named field separator

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

@@ -3,6 +3,7 @@
 * Add support for `when 'T : Enum` library-only static optimization constraint. ([PR #18546](https://github.com/dotnet/fsharp/pull/18546))
 * Add support for tail calls in computation expressions ([PR #18804](https://github.com/dotnet/fsharp/pull/18804))
 * Add `--typecheck-only` flag support for F# Interactive (FSI) scripts to type-check without execution. ([Issue #18686](https://github.com/dotnet/fsharp/issues/18686))
+* Allow comma as union case name field separator. ([PR #18833](https://github.com/dotnet/fsharp/pull/18833))
 * Diagnostics: add extended data for 'No constructors' error ([PR #18863](https://github.com/dotnet/fsharp/pull/18863))
 * FSharpType.Format: support top-level prefix generic types style. ([PR #18897](https://github.com/dotnet/fsharp/pull/18897))
 * FCS: allow getting captured types ([PR $18878](https://github.com/dotnet/fsharp/pull/18878))

docs/release-notes/.Language/preview.md

@@ -11,6 +11,7 @@
 * Allow `let!`, `use!`, `and!` type annotations without requiring parentheses (([PR #18508](https://github.com/dotnet/fsharp/pull/18508) and [PR #18682](https://github.com/dotnet/fsharp/pull/18682)))
 * Exception names are now validated for illegal characters using the same mechanism as types/modules/namespaces ([Issue #18763](https://github.com/dotnet/fsharp/issues/18763))
 * Support tail calls in computation expressions ([PR #18804](https://github.com/dotnet/fsharp/pull/18804))
+* Allow comma as union case name field separator. ([PR #18833](https://github.com/dotnet/fsharp/pull/18833))
 
 ### Fixed
 

src/Compiler/Checking/CheckRecordSyntaxHelpers.fs

@@ -59,7 +59,14 @@ let GroupUpdatesToNestedFields (fields: ((Ident list * Ident) * SynExpr option)
 /// Expands a long identifier into nested copy-and-update expressions.
 ///
 /// `{ x with A.B = 0; A.C = "" }` becomes `{ x with A = { x.A with B = 0 }; A = { x.A with C = "" } }`
-let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid: LongIdent) exprBeingAssigned withExpr =
+let TransformAstForNestedUpdates
+    (cenv: TcFileState)
+    (env: TcEnv)
+    overallTy
+    (lid: LongIdent)
+    exprBeingAssigned
+    (withExpr: SynExpr * BlockSeparator)
+    =
     let recdExprCopyInfo ids withExpr id =
         let upToId origSepRng id lidwd =
             let rec buildLid res (id: Ident) =

src/Compiler/FSComp.txt

@@ -1813,4 +1813,6 @@ featureAllowLetOrUseBangTypeAnnotationWithoutParens,"Allow let! and use! type an
 3876,lexWarnDirectivesMustMatch,"There is another %s for this warning already in line %d."
 3877,lexLineDirectiveMappingIsNotUnique,"The file '%s' was also pointed to in a line directive in '%s'. Proper warn directive application may not be possible."
 3878,tcAttributeIsNotValidForUnionCaseWithFields,"This attribute is not valid for use on union cases with fields."
+3879,parsInconsistentSeparators,"Inconsistent separators in pattern. Use either all commas or all semicolons, but not both."
 featureReturnFromFinal,"Support for ReturnFromFinal/YieldFromFinal in computation expressions to enable tailcall optimization when available on the builder."
+featureAllowCommaAsUnionCaseNamedFieldSeparator,"Allow comma as union case name field separator."

src/Compiler/Facilities/LanguageFeatures.fs

@@ -105,6 +105,7 @@ type LanguageFeature =
     | ErrorOnInvalidDeclsInTypeDefinitions
     | AllowTypedLetUseAndBang
     | ReturnFromFinal
+    | AllowCommaAsUnionCaseNamedFieldSeparator
 
 /// LanguageVersion management
 type LanguageVersion(versionText) =
@@ -245,6 +246,7 @@ type LanguageVersion(versionText) =
 
                 // F# preview (still preview in 10.0)
                 LanguageFeature.FromEndSlicing, previewVersion // Unfinished features --- needs work
+                LanguageFeature.AllowCommaAsUnionCaseNamedFieldSeparator, previewVersion
             ]
 
     static let defaultLanguageVersion = LanguageVersion("default")
@@ -415,6 +417,7 @@ type LanguageVersion(versionText) =
         | LanguageFeature.ErrorOnInvalidDeclsInTypeDefinitions -> FSComp.SR.featureErrorOnInvalidDeclsInTypeDefinitions ()
         | LanguageFeature.AllowTypedLetUseAndBang -> FSComp.SR.featureAllowLetOrUseBangTypeAnnotationWithoutParens ()
         | LanguageFeature.ReturnFromFinal -> FSComp.SR.featureReturnFromFinal ()
+        | LanguageFeature.AllowCommaAsUnionCaseNamedFieldSeparator -> FSComp.SR.featureAllowCommaAsUnionCaseNamedFieldSeparator ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -96,6 +96,7 @@ type LanguageFeature =
     | ErrorOnInvalidDeclsInTypeDefinitions
     | AllowTypedLetUseAndBang
     | ReturnFromFinal
+    | AllowCommaAsUnionCaseNamedFieldSeparator
 
 /// LanguageVersion management
 type LanguageVersion =

src/Compiler/SyntaxTree/ParseHelpers.fs

@@ -1065,9 +1065,103 @@ let leadingKeywordIsAbstract =
     | SynLeadingKeyword.StaticAbstractMember _ -> true
     | _ -> false
 
-/// Unified helper for creating let/let!/use/use! expressions
-/// Creates SynExpr.LetOrUse based on isBang parameter
-/// Handles all four cases: 'let', 'let!', 'use', and 'use!'
+let mkNamePatPairFieldFromId (id: Ident) (mEq: range option) (pat: SynPat) (sep: BlockSeparator option) : NamePatPairField =
+    let m = unionRanges id.idRange pat.Range
+    let lid = SynLongIdent([ id ], [], [ None ])
+    NamePatPairField(lid, mEq, m, pat, sep)
+
+let mkNamePatPairFieldFromLid (lid: SynLongIdent) (mEq: range option) (pat: SynPat) (sep: BlockSeparator option) : NamePatPairField =
+    let m = unionRanges lid.Range pat.Range
+    NamePatPairField(lid, mEq, m, pat, sep)
+
+let mkMissingNamePatPairFieldFromId (id: Ident) (sep: BlockSeparator option) : NamePatPairField =
+    let m = id.idRange
+    let lid = SynLongIdent([ id ], [], [ None ])
+    let bindPat = SynPat.Named(SynIdent(id, None), false, None, m)
+    let patErr = patFromParseError bindPat
+    NamePatPairField(lid, None, m, patErr, sep)
+
+let private mkVarPatFromIdent (id: Ident) =
+    SynPat.Named(SynIdent(id, None), false, None, id.idRange)
+
+let mkTuplePatFromTrailingIdents (leadingPat: SynPat) (pairs: (BlockSeparator * Ident) list) : SynPat * range =
+    match List.tryFrontAndBack pairs with
+    | None -> leadingPat, leadingPat.Range
+    | Some(front, (lastSep, lastId)) ->
+        let trailingPats = front |> List.map (fun (_, id) -> mkVarPatFromIdent id)
+        let lastPat = mkVarPatFromIdent lastId
+        let pats = leadingPat :: (trailingPats @ [ lastPat ])
+
+        let commaRanges =
+            (front |> List.map (fun (sep, _) -> sep.Range)) @ [ lastSep.Range ]
+
+        let mTuple = unionRanges leadingPat.Range lastId.idRange
+        SynPat.Tuple(false, pats, commaRanges, mTuple), mTuple
+
+let mkTuplePatFromTrailingPatterns (leadingPat: SynPat) (pairs: (BlockSeparator * SynPat) list) : SynPat * range =
+    match List.tryFrontAndBack pairs with
+    | None -> leadingPat, leadingPat.Range
+    | Some(front, (lastSep, lastPat)) ->
+        let trailingPats = front |> List.map (fun (_, p) -> p)
+        let pats = leadingPat :: (trailingPats @ [ lastPat ])
+
+        let commaRanges =
+            (front |> List.map (fun (sep, _) -> sep.Range)) @ [ lastSep.Range ]
+
+        let mTuple = unionRanges leadingPat.Range lastPat.Range
+        SynPat.Tuple(false, pats, commaRanges, mTuple), mTuple
+
+let tryFoldTuplePat (mEq1: range option) (pat1: SynPat) (pairsAsPatterns: (BlockSeparator * SynPat) list) : (SynPat * range) option =
+    match mEq1, pat1, pairsAsPatterns with
+    | Some _, SynPat.FromParseError _, _ -> None
+    | Some _, _, [] -> None
+    | Some _, _, _ -> Some(mkTuplePatFromTrailingPatterns pat1 pairsAsPatterns)
+    | None, _, _ -> None
+
+let tryFoldTuplePatFromTrailingIdents
+    (mEq1: range option)
+    (pat1: SynPat)
+    (pairsAsIdents: (BlockSeparator * Ident) list)
+    : (SynPat * range) option =
+    match mEq1, pat1, pairsAsIdents with
+    | Some _, SynPat.FromParseError _, _ -> None
+    | Some _, _, [] -> None
+    | Some _, _, _ -> Some(mkTuplePatFromTrailingIdents pat1 pairsAsIdents)
+    | None, _, _ -> None
+
+let reportInconsistentSeparatorsForNamePatPairs (fields: NamePatPairField list) =
+    // Map BlockSeparator to a kind: semicolon=0, comma=1, offside=None
+    let kindOf sep =
+        match sep with
+        | BlockSeparator.Semicolon _ -> Some 0
+        | BlockSeparator.Comma _ -> Some 1
+        | BlockSeparator.Offside _ -> None
+
+    // Find the first concrete kind (semicolon/comma) and return it together with the remaining fields to scan
+    let rec firstKind rest =
+        match rest with
+        | [] -> None
+        | NamePatPairField(blockSeparator = Some sep) :: tail ->
+            match kindOf sep with
+            | Some k -> Some(k, tail)
+            | None -> firstKind tail
+        | _ :: tail -> firstKind tail
+
+    match firstKind fields with
+    | None -> ()
+    | Some(k0, rest) ->
+        // Scan for the first conflicting separator and report once
+        let rec scan xs =
+            match xs with
+            | [] -> ()
+            | NamePatPairField(blockSeparator = Some sep) :: tail ->
+                match kindOf sep with
+                | Some k when k <> k0 -> reportParseErrorAt sep.Range (FSComp.SR.parsInconsistentSeparators ())
+                | _ -> scan tail
+            | _ :: tail -> scan tail
+
+        scan rest
+
 let mkLetExpression
     (
         isBang: bool,

src/Compiler/SyntaxTree/ParseHelpers.fsi

@@ -269,4 +269,35 @@ val mkSynField:
     leadingKeyword: SynLeadingKeyword option ->
         SynField
 
+val mkNamePatPairFieldFromId:
+    id: Ident -> mEq: range option -> pat: SynPat -> sep: BlockSeparator option -> NamePatPairField
+
+val mkNamePatPairFieldFromLid:
+    lid: SynLongIdent -> mEq: range option -> pat: SynPat -> sep: BlockSeparator option -> NamePatPairField
+
+val mkMissingNamePatPairFieldFromId: id: Ident -> sep: BlockSeparator option -> NamePatPairField
+
+/// Build a tuple pattern by folding trailing identifiers (with their comma separators)
+/// into a leading pattern. No Paren node is added; the commas are captured via commaRanges.
+/// Returns the synthesized tuple pattern and its overall range.
+val mkTuplePatFromTrailingIdents: leadingPat: SynPat -> pairs: (BlockSeparator * Ident) list -> SynPat * range
+
+/// Build a tuple pattern by folding trailing patterns (with their comma separators)
+/// into a leading pattern. No Paren node is added; the commas are captured via commaRanges.
+/// Returns the synthesized tuple pattern and its overall range.
+val mkTuplePatFromTrailingPatterns: leadingPat: SynPat -> pairs: (BlockSeparator * SynPat) list -> SynPat * range
+
+/// Try to fold trailing patterns into a tuple for a named field under recovery.
+/// Returns Some(tuplePat, mTuple) when mEq is present, pat1 is not FromParseError, and there is at least one trailing element.
+val tryFoldTuplePat:
+    mEq1: range option -> pat1: SynPat -> pairsAsPatterns: (BlockSeparator * SynPat) list -> (SynPat * range) option
+
+/// Try to fold trailing identifiers into a tuple for a named field under recovery.
+/// Returns Some(tuplePat, mTuple) when mEq is present, pat1 is not FromParseError, and there is at least one trailing ident.
+val tryFoldTuplePatFromTrailingIdents:
+    mEq1: range option -> pat1: SynPat -> pairsAsIdents: (BlockSeparator * Ident) list -> (SynPat * range) option
+
+/// Reports an error when named-field patterns mix separators within the same list.
+val reportInconsistentSeparatorsForNamePatPairs: fields: NamePatPairField list -> unit
+
 val leadingKeywordIsAbstract: SynLeadingKeyword -> bool