YamlProvider: preserve quoted scalar strings during type inference

In YAML, quoted scalars are explicitly strings by spec. Previously,
with InferTypesFromValues=true (the default), JsonInference would
re-infer values like "01234" as int even when they were explicitly
quoted as strings in the YAML source.

Fix: add a design-time parsing function (ParseToJsonValueForInference)
that substitutes quoted scalars with a non-numeric sentinel string,
so inference always returns string for them. Runtime parsing is
unchanged; only the design-time inference path is affected.

Update the expected signature for SimpleYaml.yaml to reflect that
zip: "01234" is now correctly inferred as string instead of int.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

src/FSharp.Data.DesignTime/Yaml/YamlProvider.fs

@@ -77,11 +77,11 @@ type public YamlProvider(cfg: TypeProviderConfig) as this =
 
                         if sampleIsList then
                             // If SampleIsList, parse as a YAML sequence or multiple documents
-                            match YamlDocument.ParseToJsonValue value with
+                            match YamlDocument.ParseToJsonValueForInference value with
                             | JsonValue.Array items -> items
                             | single -> [| single |]
                         else
-                            [| YamlDocument.ParseToJsonValue value |]
+                            [| YamlDocument.ParseToJsonValueForInference value |]
 
                     samples
                     |> Array.map (fun sampleJson ->

src/FSharp.Data.Yaml.Core/YamlDocument.fs

@@ -90,6 +90,62 @@ module internal YamlConversions =
         yaml.Load(reader)
         [| for doc in yaml.Documents -> yamlNodeToJsonValue doc.RootNode |]
 
+    // Like yamlNodeToJsonValue, but for design-time type inference only.
+    // In YAML, quoted scalars are always strings by spec (the quoting is an explicit type annotation).
+    // When InferTypesFromValues=true, JsonInference would otherwise re-infer "01234" as int.
+    // We prevent this by substituting a guaranteed non-numeric sentinel for quoted scalars,
+    // so inference always returns string for them. Runtime parsing still uses yamlNodeToJsonValue.
+    let rec yamlNodeToJsonValueForInference (node: YamlNode) : JsonValue =
+        match node with
+        | :? YamlMappingNode as mapping ->
+            let props =
+                [| for kvp in mapping.Children do
+                       let key =
+                           match kvp.Key with
+                           | :? YamlScalarNode as s -> s.Value
+                           | other -> other.ToString()
+
+                       yield (key, yamlNodeToJsonValueForInference kvp.Value) |]
+
+            JsonValue.Record props
+
+        | :? YamlSequenceNode as sequence ->
+            let elements =
+                [| for item in sequence.Children -> yamlNodeToJsonValueForInference item |]
+
+            JsonValue.Array elements
+
+        | :? YamlScalarNode as scalar ->
+            let value = scalar.Value
+
+            if value = null then
+                JsonValue.Null
+            else
+                match scalar.Style with
+                | YamlDotNet.Core.ScalarStyle.SingleQuoted
+                | YamlDotNet.Core.ScalarStyle.DoubleQuoted
+                | YamlDotNet.Core.ScalarStyle.Literal
+                | YamlDotNet.Core.ScalarStyle.Folded ->
+                    // Quoted scalar: YAML spec says this is always a string.
+                    // Use a non-numeric sentinel so InferTypesFromValues does not re-infer
+                    // the value content as int/bool/date/etc.
+                    JsonValue.String "quoted-string"
+                | _ ->
+                    // Plain scalars: same as runtime conversion
+                    yamlNodeToJsonValue node
+
+        | _ -> JsonValue.Null
+
+    let parseYamlForInference (text: string) : JsonValue =
+        let yaml = YamlStream()
+        use reader = new StringReader(text)
+        yaml.Load(reader)
+
+        if yaml.Documents.Count = 0 then
+            JsonValue.Null
+        else
+            yamlNodeToJsonValueForInference yaml.Documents.[0].RootNode
+
 
 // --------------------------------------------------------------------------------------
 // YamlDocument - implements IJsonDocument so it can be used with JSON-based generated code
@@ -141,6 +197,17 @@ type YamlDocument =
                                IsError = false)>]
     static member ParseToJsonValueArray(text: string) : JsonValue[] = YamlConversions.parseYamlDocuments text
 
+    /// <exclude />
+    /// Design-time only: like ParseToJsonValue but quoted scalars are represented with a
+    /// non-numeric sentinel string so that InferTypesFromValues does not re-infer them.
+    [<EditorBrowsableAttribute(EditorBrowsableState.Never)>]
+    [<CompilerMessageAttribute("This method is intended for use in generated code only.",
+                               10001,
+                               IsHidden = true,
+                               IsError = false)>]
+    static member ParseToJsonValueForInference(text: string) : JsonValue =
+        YamlConversions.parseYamlForInference text
+
     /// <exclude />
     [<EditorBrowsableAttribute(EditorBrowsableState.Never)>]
     [<CompilerMessageAttribute("This method is intended for use in generated code only.",

tests/FSharp.Data.DesignTime.Tests/expected/Yaml,SimpleYaml.yaml,False,Root,,True,False,BackwardCompatible.expected

@@ -89,7 +89,7 @@ class YamlProvider+Root : FDR.BaseTypes.IJsonDocument
 
 
 class YamlProvider+Address : FDR.BaseTypes.IJsonDocument
-    new : street:string -> city:string -> zip:int -> YamlProvider+Address
+    new : street:string -> city:string -> zip:string -> YamlProvider+Address
     JsonRuntime.CreateRecord([| ("street",
                                  (street :> obj))
                                 ("city",
@@ -114,11 +114,11 @@ class YamlProvider+Address : FDR.BaseTypes.IJsonDocument
     member WithStreet: street:string -> YamlProvider+Address
     JsonRuntime.WithRecordProperty(this, "street", (street :> obj), "")
 
-    member WithZip: zip:int -> YamlProvider+Address
+    member WithZip: zip:string -> YamlProvider+Address
     JsonRuntime.WithRecordProperty(this, "zip", (zip :> obj), "")
 
-    member Zip: int with get
+    member Zip: string with get
     let value = JsonRuntime.TryGetPropertyUnpackedWithPath(this, "zip")
-    JsonRuntime.GetNonOptionalValue(value.Path, JsonRuntime.ConvertInteger("", value.JsonOpt), value.JsonOpt)
+    JsonRuntime.GetNonOptionalValue(value.Path, JsonRuntime.ConvertString("", value.JsonOpt), value.JsonOpt)