fix: verification remediation — spec, declaration position, missing tests, and snapshots (#565, #566)

Update language spec to mark inline out declarations as implemented. Fix
inline variable declaration position to point to variable name instead of
`out` keyword. Add missing out_inline_type_mismatch error test fixture,
LSP tests for `in` modifier and out-inline-with-type token emission, and
C# snapshot tests for all out inline declaration fixtures. Fix misleading
HoverService fallback comment and null-conditional inconsistency in codegen.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: antonsynd

docs/language_specification/parameter_modifiers.md

@@ -243,7 +243,7 @@ Calculate(in largeData);  // or just Calculate(largeData)
 - *`out T` → `out T` parameter — parsed, type-checked, emitted*
 - *`in T` → `in T` parameter — parsed, type-checked, emitted*
 - *Call site `ref`/`out`/`in` keywords map directly to C#*
-- *Inline `out` declaration (`out value: int`) — not yet implemented*
+- *Inline `out` declaration (`out value: int`, `out value: auto`) — parsed, type-checked, emitted*
 
 ## See Also
 

src/Sharpy.Compiler.Tests/Integration/TestFixtures/parameter_modifiers/out_inline_auto.expected.cs

@@ -0,0 +1,26 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using global::Sharpy;
+
+public static partial class OutInlineAuto
+{
+    public static bool TryParse(string s, out int result)
+    {
+#line 2 "out_inline_auto.spy"
+        result = global::Sharpy.Builtins.Int(s);
+#line 3 "out_inline_auto.spy"
+        return true;
+    }
+
+    public static void Main()
+    {
+#line 6 "out_inline_auto.spy"
+        var success = TryParse("42", out var value);
+#line 7 "out_inline_auto.spy"
+        global::Sharpy.Builtins.Print(success, value);
+    }
+}

src/Sharpy.Compiler.Tests/Integration/TestFixtures/parameter_modifiers/out_inline_declaration.expected.cs

@@ -0,0 +1,26 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using global::Sharpy;
+
+public static partial class OutInlineDeclaration
+{
+    public static bool TryParse(string s, out int result)
+    {
+#line 2 "out_inline_declaration.spy"
+        result = global::Sharpy.Builtins.Int(s);
+#line 3 "out_inline_declaration.spy"
+        return true;
+    }
+
+    public static void Main()
+    {
+#line 6 "out_inline_declaration.spy"
+        var success = TryParse("42", out int value);
+#line 7 "out_inline_declaration.spy"
+        global::Sharpy.Builtins.Print(success, value);
+    }
+}

src/Sharpy.Compiler.Tests/Integration/TestFixtures/parameter_modifiers/out_inline_in_if.expected.cs

@@ -0,0 +1,28 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using global::Sharpy;
+
+public static partial class OutInlineInIf
+{
+    public static bool TryParse(string s, out int result)
+    {
+#line 2 "out_inline_in_if.spy"
+        result = global::Sharpy.Builtins.Int(s);
+#line 3 "out_inline_in_if.spy"
+        return true;
+    }
+
+    public static void Main()
+    {
+#line 6 "out_inline_in_if.spy"
+        if (TryParse("42", out int value))
+        {
+#line 7 "out_inline_in_if.spy"
+            global::Sharpy.Builtins.Print(value);
+        }
+    }
+}

src/Sharpy.Compiler.Tests/Integration/TestFixtures/parameter_modifiers/out_inline_multiple.expected.cs

@@ -0,0 +1,28 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using global::Sharpy;
+
+public static partial class OutInlineMultiple
+{
+    public static bool ParsePair(string s, out int a, out int b)
+    {
+#line 2 "out_inline_multiple.spy"
+        a = 10;
+#line 3 "out_inline_multiple.spy"
+        b = 20;
+#line 4 "out_inline_multiple.spy"
+        return true;
+    }
+
+    public static void Main()
+    {
+#line 7 "out_inline_multiple.spy"
+        var success = ParsePair("x", out int first, out int second);
+#line 8 "out_inline_multiple.spy"
+        global::Sharpy.Builtins.Print(success, first, second);
+    }
+}

src/Sharpy.Compiler.Tests/Integration/TestFixtures/parameter_modifiers/out_inline_type_mismatch.error

@@ -0,0 +1 @@
+Cannot pass argument of type 'str' to parameter of type 'int'

src/Sharpy.Compiler.Tests/Integration/TestFixtures/parameter_modifiers/out_inline_type_mismatch.spy

@@ -0,0 +1,7 @@
+def try_parse(s: str, result: out int) -> bool:
+    result = int(s)
+    return True
+
+def main():
+    success = try_parse("42", out value: str)
+    print(success, value)

src/Sharpy.Compiler/CodeGen/RoslynEmitter.Expressions.Access.Calls.cs

@@ -868,7 +868,7 @@ private IEnumerable<ArgumentSyntax> GeneratePositionalArguments(
                 {
                     // Map the type: "auto" → var, otherwise use TypeSyntaxMapper
                     TypeSyntax typeSyntax;
-                    if (modArg.InlineType?.Name == "auto")
+                    if (modArg.InlineType!.Name == "auto")
                     {
                         typeSyntax = IdentifierName("var");
                     }

src/Sharpy.Compiler/Semantic/TypeChecker.Expressions.cs

@@ -125,8 +125,8 @@ private SemanticType CheckModifiedArgument(ModifiedArgument modArg)
                     Kind = SymbolKind.Variable,
                     Type = resolvedType,
                     IsConstant = false,
-                    DeclarationLine = modArg.LineStart,
-                    DeclarationColumn = modArg.ColumnStart
+                    DeclarationLine = modArg.Argument.LineStart,
+                    DeclarationColumn = modArg.Argument.ColumnStart
                 };
                 _symbolTable.Define(newSymbol);
                 SemanticBinding.SetVariableType(newSymbol, resolvedType);

src/Sharpy.Lsp.Tests/SemanticTokensTests.cs

@@ -628,6 +628,33 @@ public void ModifiedArgument_OutModifier_EmitsKeywordToken()
             "'out' at the call site should produce a keyword token with length 3");
     }
 
+    [Fact]
+    public void ModifiedArgument_InModifier_EmitsKeywordToken()
+    {
+        var tokens = CollectTokensFrom(
+            "def process(x: in int):\n    print(x)\ndef main():\n    a: int = 5\n    process(in a)");
+        var keywords = tokens.Where(t => t.TokenType == TKeyword && t.Line == 4).ToList();
+        keywords.Should().Contain(t => t.Length == 2,
+            "'in' at the call site should produce a keyword token with length 2");
+    }
+
+    [Fact]
+    public void ModifiedArgument_OutInlineDeclaration_EmitsKeywordAndTypeTokens()
+    {
+        var tokens = CollectTokensFrom(
+            "def try_parse(s: str, result: out int) -> bool:\n" +
+            "    result = int(s)\n" +
+            "    return True\n" +
+            "def main():\n" +
+            "    try_parse(\"42\", out value: int)");
+        var keywordsOnCallLine = tokens.Where(t => t.TokenType == TKeyword && t.Line == 4).ToList();
+        keywordsOnCallLine.Should().Contain(t => t.Length == 3,
+            "'out' at the call site should produce a keyword token with length 3");
+        var typeTokensOnCallLine = tokens.Where(t => t.TokenType == TType && t.Line == 4).ToList();
+        typeTokensOnCallLine.Should().Contain(t => t.Length == 3,
+            "'int' inline type annotation should produce a type token");
+    }
+
     #endregion
 
     #region LambdaExpression tokens