[Repo Assist] Use explicit StringComparison.Ordinal for string comparisons (fixes #742) (#1670)

* Use explicit StringComparison.Ordinal for string operations throughout codebase

Fixes all cases of String.StartsWith, String.EndsWith, String.Contains and
String.IndexOf (with string argument) that were missing an explicit
StringComparison argument, as identified in issue #742.

Changes:
- Use StringComparison.Ordinal for all StartsWith/EndsWith comparisons
  on ASCII/code identifiers and syntax strings
- Replace String.Contains with IndexOf(char) for single-char literals
  (netstandard2.0 compatible) or IndexOf(string, StringComparison.Ordinal)
  for variable string arguments
- Replace ToLower() with ToLowerInvariant() in HtmlParser

Files changed:
- src/FSharp.Data.Runtime.Utilities/StructuralTypes.fs
- src/FSharp.Data.Runtime.Utilities/StructuralInference.fs
- src/FSharp.Data.Runtime.Utilities/NameUtils.fs
- src/FSharp.Data.Xml.Core/XmlRuntime.fs
- src/FSharp.Data.Xml.Core/XmlInference.fs
- src/FSharp.Data.Http/Http.fs
- src/FSharp.Data.DesignTime/Xml/XmlGenerator.fs
- src/FSharp.Data.Csv.Core/CsvRuntime.fs
- src/FSharp.Data.Json.Core/JsonSchema.fs
- src/FSharp.Data.Html.Core/HtmlOperations.fs
- src/FSharp.Data.Html.Core/HtmlParser.fs

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

* ci: trigger CI checks

---------

Co-authored-by: Repo Assist <repo-assist@github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Don Syme <dsyme@users.noreply.github.com>

Author: 4 people

src/FSharp.Data.Csv.Core/CsvRuntime.fs

@@ -382,7 +382,7 @@ type CsvFile<'RowType>
         let probablyTabSeparated =
             parsedCsvLines.ColumnCount < 2
             && noSeparatorsSpecified
-            && fst parsedCsvLines.FirstLine |> Array.exists (fun c -> c.Contains "\t")
+            && fst parsedCsvLines.FirstLine |> Array.exists (fun c -> c.IndexOf('\t') >= 0)
 
         let parsedCsvLines =
             if probablyTabSeparated then
@@ -474,7 +474,11 @@ type CsvFile<'RowType>
             |> writeLine (fun item ->
                 let item = item |> nullSafeguard
 
-                if item.Contains separator || item.Contains quote || item.Contains "\n" then
+                if
+                    item.IndexOf(separator, StringComparison.Ordinal) >= 0
+                    || item.IndexOf(quote, StringComparison.Ordinal) >= 0
+                    || item.IndexOf('\n') >= 0
+                then
                     writer.Write quote
                     writer.Write(item.Replace(quote, doubleQuote))
                     writer.Write quote

src/FSharp.Data.DesignTime/Xml/XmlGenerator.fs

@@ -441,7 +441,8 @@ module internal XmlTypeBuilder =
                         [ for child in children ->
 
                               let isCollectionName parentName childName =
-                                  parentName = NameUtils.pluralize childName || parentName.StartsWith childName
+                                  parentName = NameUtils.pluralize childName
+                                  || parentName.StartsWith(childName, StringComparison.Ordinal)
 
                               let child =
                                   match child with
@@ -495,9 +496,9 @@ module internal XmlTypeBuilder =
                                       let convFunc = ReflectionHelpers.makeDelegate result.Converter typeof<XmlElement>
 
                                       let isCollectionName =
-                                          names.[0].EndsWith "List"
-                                          || names.[0].EndsWith "Array"
-                                          || names.[0].EndsWith "Collection"
+                                          names.[0].EndsWith("List", StringComparison.Ordinal)
+                                          || names.[0].EndsWith("Array", StringComparison.Ordinal)
+                                          || names.[0].EndsWith("Collection", StringComparison.Ordinal)
 
                                       let name =
                                           makeUnique (
@@ -527,7 +528,12 @@ module internal XmlTypeBuilder =
                                       let convFunc = ReflectionHelpers.makeDelegate result.Converter typeof<XmlElement>
                                       let name = makeUnique names.[names.Length - 1]
 
-                                      if result.ConvertedType.Name.StartsWith "FSharpOption`1" then
+                                      if
+                                          result.ConvertedType.Name.StartsWith(
+                                              "FSharpOption`1",
+                                              StringComparison.Ordinal
+                                          )
+                                      then
                                           nameWithNS,
                                           ProvidedProperty(
                                               name,

src/FSharp.Data.Html.Core/HtmlOperations.fs

@@ -352,11 +352,15 @@ module HtmlNode =
                     selectElements' FilterLevel.Root selectedNodes t
 
                 | OpenAttribute _ :: AttributeName(_, name) :: EndWith _ :: AttributeValue(_, value) :: CloseAttribute _ :: t ->
-                    let selectedNodes = filterByAttr level acc name (fun v -> v.EndsWith value)
+                    let selectedNodes =
+                        filterByAttr level acc name (fun v -> v.EndsWith(value, StringComparison.Ordinal))
+
                     selectElements' FilterLevel.Root selectedNodes t
 
                 | OpenAttribute _ :: AttributeName(_, name) :: StartWith _ :: AttributeValue(_, value) :: CloseAttribute _ :: t ->
-                    let selectedNodes = filterByAttr level acc name (fun v -> v.StartsWith value)
+                    let selectedNodes =
+                        filterByAttr level acc name (fun v -> v.StartsWith(value, StringComparison.Ordinal))
+
                     selectElements' FilterLevel.Root selectedNodes t
 
                 | OpenAttribute _ :: AttributeName(_, name) :: AttributeContainsPrefix _ :: AttributeValue(_, value) :: CloseAttribute _ :: t ->

src/FSharp.Data.Html.Core/HtmlParser.fs

@@ -177,12 +177,12 @@ module internal HtmlParser =
             x.Tokens <- result :: x.Tokens
 
         member x.IsFormattedTag =
-            match x.CurrentTagName().ToLower() with
+            match x.CurrentTagName().ToLowerInvariant() with
             | "pre" -> true
             | _ -> false
 
         member x.IsScriptTag =
-            match x.CurrentTagName().ToLower() with
+            match x.CurrentTagName().ToLowerInvariant() with
             | "script"
             | "style" -> true
             | _ -> false

src/FSharp.Data.Http/Http.fs

@@ -1740,7 +1740,7 @@ module internal HttpHelpers =
             | "origin" -> req.Headers.["Origin"] <- value
             | "pragma" -> req.Headers.[HeaderEnum.Pragma] <- value
             | "range" ->
-                if not (value.StartsWith("bytes=")) then
+                if not (value.StartsWith("bytes=", StringComparison.Ordinal)) then
                     failwithf "Invalid value for the Range header (%O)" value
 
                 let bytes = value.Substring("bytes=".Length).Split('-')
@@ -1821,15 +1821,17 @@ module internal HttpHelpers =
                 let isText (mimeType: string) =
                     let mimeType = mimeType.Trim()
 
-                    mimeType.StartsWith "text/"
+                    mimeType.StartsWith("text/", StringComparison.Ordinal)
                     || mimeType = HttpContentTypes.Json
                     || mimeType = HttpContentTypes.Xml
                     || mimeType = HttpContentTypes.JavaScript
                     || mimeType = HttpContentTypes.JsonRpc
                     || mimeType = "application/ecmascript"
                     || mimeType = "application/xml-dtd"
-                    || mimeType.StartsWith "application/" && mimeType.EndsWith "+xml"
-                    || mimeType.StartsWith "application/" && mimeType.EndsWith "+json"
+                    || mimeType.StartsWith("application/", StringComparison.Ordinal)
+                       && mimeType.EndsWith("+xml", StringComparison.Ordinal)
+                    || mimeType.StartsWith("application/", StringComparison.Ordinal)
+                       && mimeType.EndsWith("+json", StringComparison.Ordinal)
 
                 mimeType.Split([| ';' |], StringSplitOptions.RemoveEmptyEntries)
                 |> Array.exists isText
@@ -2009,7 +2011,7 @@ type Http private () =
         | [] -> url
         | query ->
             url
-            + if url.Contains "?" then "&" else "?"
+            + if url.IndexOf('?') >= 0 then "&" else "?"
             + String.concat "&" [ for k, v in query -> Uri.EscapeDataString k + "=" + Uri.EscapeDataString v ]
 
     static member private InnerRequest

src/FSharp.Data.Json.Core/JsonSchema.fs

@@ -319,7 +319,7 @@ module JsonSchema =
         // This is a simplified implementation - a complete one would handle JSON pointers properly
         let rec resolveRef (refPath: string) =
             match refPath with
-            | path when path.StartsWith("#/") ->
+            | path when path.StartsWith("#/", StringComparison.Ordinal) ->
                 // Handle local references like "#/definitions/Point"
                 let parts = path.Substring(2).Split('/')
 

src/FSharp.Data.Runtime.Utilities/NameUtils.fs

@@ -117,7 +117,7 @@ let uniqueGenerator (niceName: string -> string) =
                 lastLetterPos <- lastLetterPos - 1
 
             if lastLetterPos = name.Length - 1 then
-                if name.Contains " " then
+                if name.IndexOf(' ') >= 0 then
                     name <- name + " 2"
                 else
                     name <- name + "2"

src/FSharp.Data.Runtime.Utilities/StructuralInference.fs

@@ -413,7 +413,7 @@ let parseUnitOfMeasure (provider: IUnitsOfMeasureProvider) (str: string) =
         uomTransformations
         |> List.collect (fun (suffixes, trans) -> suffixes |> List.map (fun suffix -> suffix, trans))
         |> List.tryPick (fun (suffix, trans) ->
-            if str.EndsWith suffix then
+            if str.EndsWith(suffix, StringComparison.Ordinal) then
                 let baseUnitStr = str.[.. str.Length - suffix.Length - 1]
                 let baseUnit = provider.SI baseUnitStr
 

src/FSharp.Data.Runtime.Utilities/StructuralTypes.fs

@@ -178,7 +178,7 @@ type internal InferedTypeTag with
     /// Parses code returned by 'Code' member (to be used in provided code)
     static member ParseCode(str: string) =
         match str with
-        | s when s.StartsWith("Record@") -> Record(Some(s.Substring("Record@".Length)))
+        | s when s.StartsWith("Record@", StringComparison.Ordinal) -> Record(Some(s.Substring("Record@".Length)))
         | "Record" -> Record None
         | "Json" -> Json
         | "Number" -> Number

src/FSharp.Data.Xml.Core/XmlInference.fs

@@ -45,7 +45,9 @@ let getInferedTypeFromValue unitsOfMeasureProvider inferenceMode cultureInfo (el
         | InferedType.Primitive(t, _, optional, _) when
             t = typeof<string>
             && let v = (element.Value).TrimStart() in
-               v.StartsWith "{" || v.StartsWith "["
+
+               v.StartsWith("{", StringComparison.Ordinal)
+               || v.StartsWith("[", StringComparison.Ordinal)
             ->
             try
                 match JsonValue.Parse(element.Value) with