Unify anonymous record fields

Author: edgarfgp

src/Compiler/Checking/CheckRecordSyntaxHelpers.fs

@@ -100,7 +100,7 @@ let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid
             )
         | _ -> None
 
-    let rec synExprRecd copyInfo (outerFieldId: Ident) innerFields exprBeingAssigned =
+    let rec synExprRecd copyInfo (outerFieldId: Ident) innerFields (exprBeingAssigned: SynExpr) =
         match innerFields with
         | [] -> failwith "unreachable"
         | (fieldId: Ident, item) :: rest ->
@@ -115,11 +115,13 @@ let TransformAstForNestedUpdates (cenv: TcFileState) (env: TcEnv) overallTy (lid
                     synExprRecd copyInfo fieldId rest exprBeingAssigned
 
             match item with
-            | Item.AnonRecdField(
-                anonInfo = {
-                               AnonRecdTypeInfo.TupInfo = TupInfo.Const isStruct
-                           }) ->
-                let fields = [ LongIdentWithDots([ fieldId ], []), None, nestedField ]
+            | Item.AnonRecdField(anonInfo = { TupInfo = TupInfo.Const isStruct }) ->
+                let fieldName = (SynLongIdent([ fieldId ], [], [ None ]), true)
+                let fieldRange = unionRanges fieldId.idRange nestedField.Range
+
+                let fields =
+                    [ SynExprRecordField(fieldName, None, Some nestedField, fieldRange, None) ]
+
                 SynExpr.AnonRecd(isStruct, copyInfo outerFieldId, fields, outerFieldId.idRange, { OpeningBraceRange = range0 })
             | _ ->
                 let fields =

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -7855,42 +7855,69 @@ and CheckAnonRecdExprDuplicateFields (elems: Ident array) =
                errorR(Error (FSComp.SR.tcAnonRecdDuplicateFieldId(uc1.idText), uc1.idRange))))
 
 // Check '{| .... |}'
-and TcAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, optOrigSynExpr, unsortedFieldIdsAndSynExprsGiven, mWholeExpr) =
+and TcAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, optOrigSynExpr, recordFields: SynExprRecordField list, mWholeExpr) =
     match optOrigSynExpr with
     | None ->
-        TcNewAnonRecdExpr cenv overallTy env tpenv (isStruct, unsortedFieldIdsAndSynExprsGiven, mWholeExpr)
+        TcNewAnonRecdExpr cenv overallTy env tpenv (isStruct, recordFields, mWholeExpr)
 
     | Some orig ->
         // Ideally we should also check for duplicate field IDs in the TcCopyAndUpdateAnonRecdExpr case, but currently the logic is too complex to guarantee a proper error reporting
         // So here we error instead errorR to avoid cascading  internal errors
-        unsortedFieldIdsAndSynExprsGiven
-        |> List.countBy (fun (fId, _, _) -> textOfLid fId.LongIdent)
+        recordFields
+        |> List.countBy (fun (SynExprRecordField(fieldName = (fId, _))) -> textOfLid fId.LongIdent)
         |> List.iter (fun (label, count) ->
             if count > 1 then error (Error (FSComp.SR.tcAnonRecdDuplicateFieldId(label), mWholeExpr)))
 
-        TcCopyAndUpdateAnonRecdExpr cenv overallTy env tpenv (isStruct, orig, unsortedFieldIdsAndSynExprsGiven, mWholeExpr)
+        TcCopyAndUpdateAnonRecdExpr cenv overallTy env tpenv (isStruct, orig, recordFields, mWholeExpr)
 
-and TcNewAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, unsortedFieldIdsAndSynExprsGiven, mWholeExpr) =
+and TcNewAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, recordFields: SynExprRecordField list, mWholeExpr) =
 
     let g = cenv.g
-    let unsortedFieldSynExprsGiven = unsortedFieldIdsAndSynExprsGiven |> List.map (fun (_, _, fieldExpr) -> fieldExpr)
-    let unsortedFieldIds = unsortedFieldIdsAndSynExprsGiven |> List.map (fun (synLongIdent, _, _) -> synLongIdent.LongIdent[0]) |> List.toArray
-    let anonInfo, sortedFieldTys = UnifyAnonRecdTypeAndInferCharacteristics env.eContextInfo cenv env.DisplayEnv mWholeExpr overallTy isStruct unsortedFieldIds
+
+    // For new anonymous records, each field label must be a single identifier.
+    // If a long identifier is given, report an error and skip that entry for typechecking purposes.
+    // Also normalize missing expressions to an error expression to keep traversal stable.
+    let validFields : (Ident * SynExpr * SynLongIdent) list =
+        recordFields
+        |> List.choose (fun (SynExprRecordField(fieldName = (synLongIdent, _); expr = e; range = mField)) ->
+            match synLongIdent.LongIdent with
+            | [ id ] ->
+                let exprGiven =
+                    match e with
+                    | Some e -> e
+                    | None -> SynExpr.FromParseError(SynExpr.Const(SynConst.Unit, mField), mField)
+                Some(id, exprGiven, synLongIdent)
+            | [] ->
+                // Should not occur for anonymous record expressions; silently skip with a diagnostic.
+                errorR (Error(FSComp.SR.parsInvalidAnonRecdType(), synLongIdent.Range))
+                None
+            | _ ->
+                // Nested labels are only valid in copy-and-update; not allowed for new anonymous records
+                errorR (Error(FSComp.SR.parsInvalidAnonRecdType(), synLongIdent.Range))
+                None)
+
+    let unsortedFieldSynExprsGiven = validFields |> List.map (fun (_, e, _) -> e)
+
+    let unsortedFieldIds = validFields |> List.map (fun (id, _, _) -> id) |> List.toArray
+
+    let anonInfo, sortedFieldTys =
+        UnifyAnonRecdTypeAndInferCharacteristics env.eContextInfo cenv env.DisplayEnv mWholeExpr overallTy isStruct unsortedFieldIds
 
     if unsortedFieldIds.Length > 1 then
         CheckAnonRecdExprDuplicateFields unsortedFieldIds
 
     // Sort into canonical order
     let sortedIndexedArgs =
-        unsortedFieldIdsAndSynExprsGiven
+        validFields
         |> List.indexed
         |> List.sortBy (fun (i,_) -> unsortedFieldIds[i].idText)
 
     // Map from sorted indexes to unsorted indexes
     let sigma = sortedIndexedArgs |> List.map fst |> List.toArray
-    let sortedFieldExprs = sortedIndexedArgs |> List.map snd
+    let sortedFieldTriples = sortedIndexedArgs |> List.map snd
 
-    sortedFieldExprs |> List.iteri (fun j (synLongIdent, _, _) ->
+    sortedFieldTriples
+    |> List.iteri (fun j (_, _, synLongIdent) ->
         let m = rangeOfLid synLongIdent.LongIdent
         let item = Item.AnonRecdField(anonInfo, sortedFieldTys, j, m)
         CallNameResolutionSink cenv.tcSink (m, env.NameEnv, item, emptyTyparInst, ItemOccurrence.Use, env.eAccessRights))
@@ -7903,11 +7930,12 @@ and TcNewAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, unsortedField
 
     let flexes = unsortedFieldTys |> List.map (fun _ -> true)
 
-    let unsortedCheckedArgs, tpenv = TcExprsWithFlexes cenv env mWholeExpr tpenv flexes unsortedFieldTys unsortedFieldSynExprsGiven
+    let unsortedCheckedArgs, tpenv =
+        TcExprsWithFlexes cenv env mWholeExpr tpenv flexes unsortedFieldTys unsortedFieldSynExprsGiven
 
     mkAnonRecd g mWholeExpr anonInfo unsortedFieldIds unsortedCheckedArgs unsortedFieldTys, tpenv
 
-and TcCopyAndUpdateAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, (origExpr, blockSeparator), unsortedFieldIdsAndSynExprsGiven, mWholeExpr) =
+and TcCopyAndUpdateAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, (origExpr, blockSeparator), recordFields: SynExprRecordField list, mWholeExpr) =
     // The fairly complex case '{| origExpr with X = 1; Y = 2 |}'
     // The origExpr may be either a record or anonymous record.
     // The origExpr may be either a struct or not.
@@ -7926,14 +7954,17 @@ and TcCopyAndUpdateAnonRecdExpr cenv (overallTy: TType) env tpenv (isStruct, (or
     if not (isAppTy g origExprTy || isAnonRecdTy g origExprTy) then
         error (Error (FSComp.SR.tcCopyAndUpdateNeedsRecordType(), mOrigExpr))
 
-    // Expand expressions with respect to potential nesting
+    // Expand expressions with respect to potentially nesting
     let unsortedFieldIdsAndSynExprsGiven =
-        unsortedFieldIdsAndSynExprsGiven
-        |> List.map (fun (synLongIdent, _, exprBeingAssigned) ->
+        recordFields
+        |> List.map (fun (SynExprRecordField(fieldName = (synLongIdent, _); expr = e)) ->
             match synLongIdent.LongIdent with
             | [] -> error(Error(FSComp.SR.nrUnexpectedEmptyLongId(), mWholeExpr))
-            | [ id ] -> ([], id), Some exprBeingAssigned
-            | lid -> TransformAstForNestedUpdates cenv env origExprTy lid exprBeingAssigned (origExpr, blockSeparator))
+            | [ id ] -> ([], id), e
+            | lid ->
+                match e with
+                | Some exprBeingAssigned -> TransformAstForNestedUpdates cenv env origExprTy lid exprBeingAssigned (origExpr, blockSeparator)
+                | None -> List.frontAndBack lid, None)
         |> GroupUpdatesToNestedFields
 
     let unsortedFieldSynExprsGiven = unsortedFieldIdsAndSynExprsGiven |> List.choose snd

src/Compiler/Driver/GraphChecking/FileContentMapping.fs

@@ -378,8 +378,15 @@ let visitSynExpr (e: SynExpr) : FileContentEntry list =
         | SynExpr.AnonRecd(copyInfo = copyInfo; recordFields = recordFields) ->
             let continuations =
                 match copyInfo with
-                | None -> List.map (fun (_, _, e) -> visit e) recordFields
-                | Some(cp, _) -> visit cp :: List.map (fun (_, _, e) -> visit e) recordFields
+                | None ->
+                    recordFields
+                    |> List.choose (fun (SynExprRecordField(expr = e)) -> e)
+                    |> List.map visit
+                | Some(cp, _) ->
+                    visit cp
+                    :: (recordFields
+                        |> List.choose (fun (SynExprRecordField(expr = e)) -> e)
+                        |> List.map visit)
 
             Continuation.concatenate continuations continuation
         | SynExpr.ArrayOrList(exprs = exprs) ->

src/Compiler/Service/FSharpParseFileResults.fs

@@ -641,7 +641,7 @@ type FSharpParseFileResults(diagnostics: FSharpDiagnostic[], input: ParsedInput,
                             | Some(e, _) -> yield! walkExpr true e
                             | None -> ()
 
-                            yield! walkExprs (fs |> List.map (fun (_, _, e) -> e))
+                            yield! walkExprs (fs |> List.choose (fun (SynExprRecordField(expr = e)) -> e))
 
                         | SynExpr.ObjExpr(argOptions = args; bindings = bs; members = ms; extraImpls = is) ->
                             let bs = unionBindingAndMembers bs ms

src/Compiler/Service/ServiceParseTreeWalk.fs

@@ -458,9 +458,42 @@ module SyntaxTraversal =
                                         None)
                         | _ -> ()
 
-                        for field, _, x in fields do
-                            yield dive () field.Range (fun () -> visitor.VisitRecordField(path, copyOpt |> Option.map fst, Some field))
-                            yield dive x x.Range traverseSynExpr
+                        let copyOpt = Option.map fst copyOpt
+
+                        for SynExprRecordField(fieldName = (field, _); expr = e; blockSeparator = sepOpt) in fields do
+                            yield
+                                dive (path, copyOpt, Some field) field.Range (fun r ->
+                                    if rangeContainsPos field.Range pos then
+                                        visitor.VisitRecordField r
+                                    else
+                                        None)
+
+                            match e with
+                            | Some e ->
+                                yield
+                                    dive e e.Range (fun inner ->
+                                        // special case: caret is below field binding
+                                        // field x = 5
+                                        // $
+                                        if
+                                            not (rangeContainsPos e.Range pos)
+                                            && sepOpt.IsNone
+                                            && pos.Column = field.Range.StartColumn
+                                        then
+                                            visitor.VisitRecordField(path, copyOpt, None)
+                                        else
+                                            traverseSynExpr inner)
+                            | None -> ()
+
+                            match sepOpt with
+                            | Some blockSep ->
+                                yield
+                                    dive () blockSep.Range (fun () ->
+                                        if posGeq pos blockSep.Range.End then
+                                            visitor.VisitRecordField(path, copyOpt, None)
+                                        else
+                                            None)
+                            | _ -> ()
                     ]
                     |> pick expr
 

src/Compiler/Service/SynExpr.fs

@@ -1121,8 +1121,8 @@ module SynExpr =
                 let rec loop recordFields =
                     match recordFields with
                     | [] -> false
-                    | (_, Some _blockSeparator, SynExpr.Paren(expr = Is inner)) :: (SynLongIdent(id = id :: _), _, _) :: _ ->
-                        problematic inner.Range id.idRange
+                    | SynExprRecordField(expr = Some(SynExpr.Paren(expr = Is inner)); blockSeparator = Some _) :: SynExprRecordField(
+                        fieldName = SynLongIdent(id = id :: _), _) :: _ -> problematic inner.Range id.idRange
                     | _ :: recordFields -> loop recordFields
 
                 loop recordFields

src/Compiler/SyntaxTree/SyntaxTree.fs

@@ -550,7 +550,7 @@ type SynExpr =
     | AnonRecd of
         isStruct: bool *
         copyInfo: (SynExpr * BlockSeparator) option *
-        recordFields: (SynLongIdent * range option * SynExpr) list *
+        recordFields: SynExprRecordField list *
         range: range *
         trivia: SynExprAnonRecdTrivia
 

src/Compiler/SyntaxTree/SyntaxTree.fsi

@@ -608,7 +608,7 @@ type SynExpr =
     | AnonRecd of
         isStruct: bool *
         copyInfo: (SynExpr * BlockSeparator) option *
-        recordFields: (SynLongIdent * range option * SynExpr) list *
+        recordFields: SynExprRecordField list *
         range: range *
         trivia: SynExprAnonRecdTrivia
 

src/Compiler/SyntaxTree/SyntaxTreeOps.fs

@@ -915,11 +915,12 @@ let rec synExprContainsError inpExpr =
         | SynExpr.ArrayOrList(_, es, _)
         | SynExpr.Tuple(_, es, _, _) -> walkExprs es
 
-        | SynExpr.AnonRecd(copyInfo = origExpr; recordFields = flds) ->
+        | SynExpr.AnonRecd(copyInfo = origExpr; recordFields = fs) ->
             (match origExpr with
              | Some(e, _) -> walkExpr e
              | None -> false)
-            || walkExprs (List.map (fun (_, _, e) -> e) flds)
+            || (let flds = fs |> List.choose (fun (SynExprRecordField(expr = v)) -> v)
+                walkExprs flds)
 
         | SynExpr.Record(_, origExpr, fs, _) ->
             (match origExpr with

src/Compiler/pars.fsy

@@ -5912,12 +5912,6 @@ braceBarExpr:
 braceBarExprCore:
   | LBRACE_BAR recdExprCore bar_rbrace
      { let orig, flds = $2
-       let flds =
-           flds |> List.choose (function
-             | SynExprRecordField((synLongIdent, _), mEquals, Some e, _, _) when orig.IsSome -> Some(synLongIdent, mEquals, e) // copy-and-update, long identifier signifies nesting
-             | SynExprRecordField((SynLongIdent([ _id ], _, _) as synLongIdent, _), mEquals, Some e, _, _) -> Some(synLongIdent, mEquals, e) // record construction, long identifier not valid
-             | SynExprRecordField((synLongIdent, _), mEquals, None, _, _) -> Some(synLongIdent, mEquals, arbExpr ("anonField", synLongIdent.Range))
-             | _ -> reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsInvalidAnonRecdType()); None)
        let mLeftBrace = rhs parseState 1
        let mRightBrace = rhs parseState 3
        (fun (mStruct: range option) ->
@@ -5927,10 +5921,6 @@ braceBarExprCore:
   | LBRACE_BAR recdExprCore recover
      { reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnmatchedBraceBar())
        let orig, flds = $2
-       let flds =
-           flds |> List.map (function
-             | SynExprRecordField((synLongIdent, _), mEquals, Some e, _, _) -> (synLongIdent, mEquals, e)
-             | SynExprRecordField((synLongIdent, _), mEquals, None, _, _) -> (synLongIdent, mEquals, arbExpr ("anonField", synLongIdent.Range)))
        let mLeftBrace = rhs parseState 1
        let mExpr = rhs parseState 2
        (fun (mStruct: range option) ->