Merge branch 'feature/langserver-rewrite-csharp'

Author: pchalamet

CHANGELOG.md

@@ -17,6 +17,9 @@ All notable changes to FScript are documented in this file.
 - Switched C# LSP host to full-method dispatch parity via shared handlers, made it the default test target, and updated extension/tag packaging to use `FScript.LanguageServer.dll`.
 - Replaced the F# LSP server executable with `FScript.LanguageServer` (C#) and moved F# LSP logic into `FScript.LanguageServer.Core`.
 - Fixed imported qualified type annotations (for example `common.ProjectInfo`) in parser/type inference to prevent false type mismatches.
+- Fixed LSP inlay hints to ignore spans from other files so included symbols no longer leak labels into unrelated declarations.
+- Enforced string-only map keys across type inference, evaluation, samples, and LSP type rendering (removed `int|string` key-domain displays).
+- Fixed map-pattern inlay hints to infer key/value/tail bindings (`string`, `int`, `int map`) instead of `unknown`.
 
 ## [0.33.0]
 

README.md

@@ -30,7 +30,7 @@ FScript currently includes:
 - optional type annotations on parameters,
 - type declarations: records and unions (including recursive forms),
 - interpolation, pipeline operator, `typeof` type tokens, and `nameof` identifier tokens for host workflows.
-- unified brace literals for records/maps (`{ Field = value }`, `{ [key] = value }`, `{}` for empty map), with map keys typed as `string` or `int`.
+- unified brace literals for records/maps (`{ Field = value }`, `{ [key] = value }`, `{}` for empty map), with map keys typed as `string`.
 
 ## Getting Started Tutorial
 

docs/guides/getting-started-tutorial.md

@@ -165,10 +165,10 @@ let maybeMath = scores |> Map.tryGet "math"
 print $"{maybeMath}"
 ```
 
-Map keys can be `string` or `int`:
+Map keys are `string`:
 
 ```fsharp
-let status = { [200] = "ok"; [404] = "not-found" }
+let status = { ["200"] = "ok"; ["404"] = "not-found" }
 ```
 
 ### Discriminated union

docs/guides/language-choices.md

@@ -21,7 +21,6 @@ let x =
   - `'a map`
 - Map values use native literals:
   - `{ ["a"] = 1; ["b"] = 2 }`
-  - `{ [1] = "one"; [2] = "two" }`
 - Map update/merge is available directly in literals:
   - `{ ["a"] = 1; ..tail }`
 - Function types use arrow syntax:
@@ -56,7 +55,6 @@ let x =
 - Typed decoding workflows use `typeof Name` tokens with host externs.
 - Capability maps can use `nameof identifier` for stable script-side function keys.
 - Capability maps use string keys in map literals (`[expr]` where `expr : string`).
-- Maps also support integer keys (`[expr]` where `expr : int`) for numeric indexing scenarios.
 
 ## Formatting and layout choices
 - `match` case columns align.

docs/specs/lsp-inlay-hints.md

@@ -48,10 +48,8 @@ match firstEven with
 Formatting follows LSP-friendly type rendering rules:
 - unknown inferred variable: `unknown`
 - map value type when key domain is unresolved: `unknown map`
-- map key-domain variable constrained by language map rules: `int|string`
 
 Examples:
-- `: int|string`
 - `: unknown map`
 
 ## Configuration

docs/specs/map-matching-reference.md

@@ -12,13 +12,7 @@ match values with
 | _ -> ""
 ```
 
-Keys can be `string` or `int`:
-
-```fsharp
-match codes with
-| { [200] = label } -> label
-| _ -> "missing"
-```
+Keys must be `string`.
 
 ## Supported forms
 
@@ -86,7 +80,6 @@ let describe values =
 - Map literals:
   - `{}` empty map
   - `{ ["k"] = v }`
-  - `{ [1] = v }`
   - `{ ["k"] = v; ..tail }`
 - For map construction/update rules, see [`supported-types.md`](./supported-types.md).
 - For full syntax/layout rules, see [`syntax-and-indentation.md`](./syntax-and-indentation.md).

docs/specs/stdlib-functions.md

@@ -56,7 +56,7 @@ The stdlib is loaded automatically by `FScript.Language` before user scripts.
 - `Map.iter : ('k -> 'v -> unit) -> map<'k, 'v> -> unit`
 - `Map.remove : 'k -> map<'k, 'v> -> map<'k, 'v>`
 
-Map key support in FScript currently allows `string` and `int` keys.
+Map keys in FScript are string-only.
 
 ## Quick examples
 ```fsharp
@@ -67,7 +67,6 @@ let maybePort = Some 8080
 let port = maybePort |> Option.defaultValue 80
 
 let m = { ["a"] = 1; ["b"] = 2 }
-let n = { [1] = "one"; [2] = "two" }
 let hasA = Map.containsKey "a" m
-let one = n[1] |> Option.defaultValue "missing"
+let one = m["a"] |> Option.defaultValue 0
 ```

docs/specs/supported-types.md

@@ -22,10 +22,9 @@ This document specifies the value and type system used by the interpreter.
 - Native map literal syntax:
   - empty: `{}`
   - populated: `{ ["a"] = 1; ["b"] = 2 }`
-  - int keys: `{ [1] = "one"; [2] = "two" }`
   - spread update: `{ ["a"] = 1; ..tail }`
   - multiline entries are supported in an indented block.
-- Keys are bracketed expressions and must have type `string` or `int` (for example `{ [keyExpr] = value }`).
+- Keys are bracketed expressions and must have type `string` (for example `{ [keyExpr] = value }`).
 - Record literals and map literals share `{ ... }` braces:
   - map entries use `[expr] = value`
   - record entries use `Field = value`

docs/specs/syntax-and-indentation.md

@@ -38,7 +38,6 @@ This document describes the concrete syntax accepted by the interpreter and the
   - record patterns in cases: `{ Field = pattern; ... }`
   - map patterns in cases support keyed lookup and extraction:
     - keyed lookup: `{ ["key"] = v }`
-    - int-key lookup: `{ [1] = v }`
     - multiple keys: `{ ["a"] = x; ["b"] = y }`
     - optional tail capture: `{ ["a"] = x; ..tail }`
     - dynamic extraction (preserved): `{ [k] = v; ..tail }`
@@ -58,12 +57,11 @@ This document describes the concrete syntax accepted by the interpreter and the
 - Maps:
   - empty `{}`
   - literal `{ ["a"] = 1; ["b"] = 2 }`
-  - int-key literal `{ [1] = "one"; [2] = "two" }`
   - update/merge with spread `{ ["a"] = 1; ..tail }`
   - map entries always use bracketed keys (`[expr] = value`)
   - record entries use field assignments (`Field = value`)
   - when braces are empty (`{}`), the literal is a map
-  - keys are bracketed expressions (`[expr]`) and must infer to `string` or `int`
+  - keys are bracketed expressions (`[expr]`) and must infer to `string`
   - if entries start on the next line, `{` must be on its own line
   - multiline example:
   ```fsharp

samples/map-matching.fss

@@ -5,9 +5,9 @@ let values =
       ["gamma"] = 30 }
 
 let indexed =
-    { [1] = "one"
-      [2] = "two"
-      [3] = "three" }
+    { ["1"] = "one"
+      ["2"] = "two"
+      ["3"] = "three" }
 
 match values with
 | { ["alpha"] = v1; ..tail } ->
@@ -25,6 +25,6 @@ match values with
 | _ -> print "no dynamic match"
 
 match indexed with
-| { [1] = first; [2] = second; ..tail } ->
-    print $"int-key match: first={first}, second={second}, tail={tail}"
-| _ -> print "no int-key match"
+| { ["1"] = first; ["2"] = second; ..tail } ->
+    print $"string-key match: first={first}, second={second}, tail={tail}"
+| _ -> print "no string-key match"