refactor(semantic): every expectation push goes through EnterStore — 26 raw _expectedType writes migrated

StoreContext records position/slot/callee/ordinal (no consumer yet).
ClearExpectation handles the 7 null-push sites.
StoreSeamConformanceTests.ExpectationIsPushedOnlyThroughEnterStore
scans for raw writes (0) and anchors the call-site count to 38.

mutation: raw write reintroduced → red (1 failed), restored → green

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017WDHWSPvShmKRoGytd9ZXw

Author: antonsynd

src/Sharpy.Compiler.Tests/Semantic/StoreSeamConformanceTests.cs

@@ -173,6 +173,88 @@ public void Scan_FindsTheKnownCallSites()
                 "IsAssignable is the one place a data-level call belongs");
     }
 
+    /// <summary>
+    /// Every <c>_expectedType =</c> write in the checker must go through <c>EnterStore</c> or
+    /// <c>ClearExpectation</c> (plan-ebd58b Phase 1). A raw write bypasses the save/restore seam
+    /// and the <c>StoreContext</c> record, which is the defect class Phase 2 reads to compose
+    /// diagnostic context.
+    /// </summary>
+    [Fact]
+    public void ExpectationIsPushedOnlyThroughEnterStore()
+    {
+        var semanticDir = FindCompilerSemanticDirectory();
+        var files = Directory.GetFiles(semanticDir, "TypeChecker*.cs", SearchOption.TopDirectoryOnly);
+
+        files.Should().NotBeEmpty("positive control: the scan must find TypeChecker files");
+
+        var violations = new List<string>();
+        var enterStoreCount = 0;
+        var clearExpectationCount = 0;
+        var scannedFileCount = 0;
+
+        foreach (var file in files)
+        {
+            var fileName = Path.GetFileName(file);
+
+            // The seam itself is the ONE file allowed to write _expectedType
+            if (fileName == "TypeChecker.StoreConversion.cs")
+                continue;
+
+            scannedFileCount++;
+            var text = File.ReadAllText(file);
+            var lines = text.Split('\n');
+
+            for (int i = 0; i < lines.Length; i++)
+            {
+                var line = lines[i];
+                var trimmed = line.TrimStart();
+
+                // Skip comments
+                if (trimmed.StartsWith("//") || trimmed.StartsWith("*") || trimmed.StartsWith("///"))
+                    continue;
+
+                // Field declaration is allowed: `private SemanticType? _expectedType = null;`
+                if (trimmed.Contains("private") && trimmed.Contains("SemanticType?") && trimmed.Contains("_expectedType"))
+                    continue;
+
+                // Check for raw `_expectedType =` writes (assignment, not comparison)
+                if (System.Text.RegularExpressions.Regex.IsMatch(line, @"_expectedType\s*=[^=]"))
+                    violations.Add($"{fileName}:{i + 1}: {trimmed.TrimEnd()}");
+
+                // Check for `ref _expectedType` (ScopedValue.Push)
+                if (line.Contains("ref _expectedType"))
+                    violations.Add($"{fileName}:{i + 1}: {trimmed.TrimEnd()}");
+            }
+
+            // Count EnterStore and ClearExpectation call sites in this file
+            enterStoreCount += System.Text.RegularExpressions.Regex.Matches(text, @"EnterStore\(").Count;
+            clearExpectationCount += System.Text.RegularExpressions.Regex.Matches(text, @"ClearExpectation\(").Count;
+        }
+
+        // Also count EnterStore/ClearExpectation in StoreConversion.cs (only the definition,
+        // not call sites — but the definition includes the method name)
+        var storeConversionText = File.ReadAllText(Path.Combine(semanticDir, "TypeChecker.StoreConversion.cs"));
+        enterStoreCount += System.Text.RegularExpressions.Regex.Matches(storeConversionText, @"EnterStore\(").Count;
+        // Subtract 1 for the definition itself
+        enterStoreCount -= 1;
+        clearExpectationCount += System.Text.RegularExpressions.Regex.Matches(storeConversionText, @"ClearExpectation\(").Count;
+        // Subtract 1 for the definition itself
+        clearExpectationCount -= 1;
+
+        violations.Should().BeEmpty(
+            "every _expectedType write must go through EnterStore or ClearExpectation — "
+            + "a raw write bypasses the save/restore seam and the StoreContext record. Found: "
+            + string.Join("; ", violations));
+
+        scannedFileCount.Should().BeGreaterThan(0,
+            "positive control: the scan must examine at least one TypeChecker file");
+
+        var totalCallSites = enterStoreCount + clearExpectationCount;
+        totalCallSites.Should().Be(38,
+            "the literal anchor for EnterStore + ClearExpectation call sites "
+            + $"(got {enterStoreCount} EnterStore + {clearExpectationCount} ClearExpectation = {totalCallSites})");
+    }
+
     private record CallSite(string File, string Method, int Line, string Text)
     {
         public string Key => $"{File}::{Method}";

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

@@ -3800,10 +3800,9 @@ private SemanticType CheckIifeLambdaCall(FunctionCall call, LambdaExpression lam
         };
 
         // 4. Check lambda with expected type context
-        var saved = _expectedType;
-        _expectedType = expectedFuncType;
-        var lambdaType = CheckExpression(call.Function);
-        _expectedType = saved;
+        SemanticType lambdaType;
+        using (EnterStore(StorePosition.ArgumentPositional, expectedFuncType, call.Function))
+            lambdaType = CheckExpression(call.Function);
 
         // 5. Return the inferred return type
         return lambdaType is FunctionType ft ? ft.ReturnType : SemanticType.Unknown;
@@ -4079,7 +4078,6 @@ private SemanticType CheckUnionCaseConstruction(
         {
             for (int argIdx = 0; argIdx < call.Arguments.Length; argIdx++)
             {
-                var previousExpectedType = _expectedType;
                 var previousParameterTypedArgument = _parameterTypedArgument;
 
                 // Cleared up front, so the arms below can only ever set it TOGETHER with the
@@ -4107,7 +4105,6 @@ private SemanticType CheckUnionCaseConstruction(
                         else
                             argTypes.Add(SemanticType.Unknown);
                     }
-                    _expectedType = previousExpectedType;
                     _parameterTypedArgument = previousParameterTypedArgument;
                     continue;
                 }
@@ -4119,24 +4116,27 @@ private SemanticType CheckUnionCaseConstruction(
                     && earlyFuncSymbol != null && argIdx + earlyParamOffset < earlyFuncSymbol.Parameters.Count)
                 {
                     var paramType = earlyFuncSymbol.Parameters[argIdx + earlyParamOffset].Type;
-                    _expectedType = paramType is UnknownType ? null : paramType;
-                    _parameterTypedArgument = ParameterTypedArgumentOf(paramType, call.Arguments[argIdx]);
+                    using (EnterStore(StorePosition.ArgumentPositional, paramType, call.Arguments[argIdx]))
+                        argTypes.Add(CheckExpression(call.Arguments[argIdx]));
                 }
                 else if (!noCandidateExpectation
                     && calleeFunctionType != null && argIdx < calleeFunctionType.ParameterTypes.Count)
                 {
                     var paramType = calleeFunctionType.ParameterTypes[argIdx];
-                    _expectedType = paramType is UnknownType ? null : paramType;
-                    _parameterTypedArgument = ParameterTypedArgumentOf(paramType, call.Arguments[argIdx]);
+                    using (EnterStore(StorePosition.ArgumentPositional, paramType, call.Arguments[argIdx]))
+                        argTypes.Add(CheckExpression(call.Arguments[argIdx]));
                 }
                 else if (noCandidateExpectation)
                 {
                     // The ENCLOSING context's expectation is not this argument's parameter type
                     // either, and leaving it in place would type the literal from it.
-                    _expectedType = null;
+                    using (ClearExpectation(call.Arguments[argIdx]))
+                        argTypes.Add(CheckExpression(call.Arguments[argIdx]));
+                }
+                else
+                {
+                    argTypes.Add(CheckExpression(call.Arguments[argIdx]));
                 }
-                argTypes.Add(CheckExpression(call.Arguments[argIdx]));
-                _expectedType = previousExpectedType;
                 _parameterTypedArgument = previousParameterTypedArgument;
             }
         }
@@ -4158,24 +4158,27 @@ private SemanticType CheckUnionCaseConstruction(
                     span: kwarg.Span ?? kwarg.Value.Span);
             }
 
-            var previousExpectedType = _expectedType;
             var previousParameterTypedArgument = _parameterTypedArgument;
             _parameterTypedArgument = null;
-            if (calleeDenotesOverloadSet && TakesContextualCollectionType(kwarg.Value))
+            IDisposable? kwScope = null;
+            try
             {
-                _expectedType = null;
-            }
-            else if (earlyFuncSymbol != null)
-            {
-                var param = FindKeywordParameter(earlyFuncSymbol.Parameters, kwarg.Name);
-                if (param != null)
+                if (calleeDenotesOverloadSet && TakesContextualCollectionType(kwarg.Value))
                 {
-                    _expectedType = param.Type is UnknownType ? null : param.Type;
-                    _parameterTypedArgument = ParameterTypedArgumentOf(param.Type, kwarg.Value);
+                    kwScope = ClearExpectation(kwarg.Value);
                 }
+                else if (earlyFuncSymbol != null)
+                {
+                    var param = FindKeywordParameter(earlyFuncSymbol.Parameters, kwarg.Name);
+                    if (param != null)
+                        kwScope = EnterStore(StorePosition.ArgumentKeyword, param.Type, kwarg.Value, keywordName: kwarg.Name);
+                }
+                kwargTypes[kwarg.Name] = CheckExpression(kwarg.Value);
+            }
+            finally
+            {
+                kwScope?.Dispose();
             }
-            kwargTypes[kwarg.Name] = CheckExpression(kwarg.Value);
-            _expectedType = previousExpectedType;
             _parameterTypedArgument = previousParameterTypedArgument;
         }
 
@@ -4229,26 +4232,28 @@ private bool TryCheckMapLambdaArguments(FunctionCall call, Expression callee, Li
         // that CheckLambda ignores (it maps only up to the lambda's own arity).
         var elementTypes = new List<SemanticType>();
         var iterableTypes = new List<SemanticType>();
-        var previousExpectedType = _expectedType;
-        _expectedType = null;
-        for (int i = 1; i < call.Arguments.Length; i++)
+        using (ClearExpectation(null))
         {
-            var argType = CheckExpression(call.Arguments[i]);
-            iterableTypes.Add(argType);
-            var elem = _typeInference.InferIterableElementType(argType);
-            elementTypes.Add(elem ?? SemanticType.Unknown);
+            for (int i = 1; i < call.Arguments.Length; i++)
+            {
+                var argType = CheckExpression(call.Arguments[i]);
+                iterableTypes.Add(argType);
+                var elem = _typeInference.InferIterableElementType(argType);
+                elementTypes.Add(elem ?? SemanticType.Unknown);
+            }
         }
 
         // Feed the synthesized expected function type into the lambda so CheckLambda types its
         // parameters from the element types (lambdas/CheckLambda already consume a FunctionType
         // _expectedType). The return type is left Unknown; the body determines it.
-        _expectedType = new FunctionType
+        var expectedMapFuncType = new FunctionType
         {
             ParameterTypes = elementTypes,
             ReturnType = SemanticType.Unknown
         };
-        var lambdaType = CheckExpression(call.Arguments[0]);
-        _expectedType = previousExpectedType;
+        SemanticType lambdaType;
+        using (EnterStore(StorePosition.ArgumentPositional, expectedMapFuncType, call.Arguments[0]))
+            lambdaType = CheckExpression(call.Arguments[0]);
 
         // Reassemble positional argTypes in source order: [lambda, iter1, iter2, ...].
         argTypes.Add(lambdaType);

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

@@ -282,10 +282,16 @@ private bool TryCheckDeferredLambdaArguments(
         {
             if (deferredPositions.Contains(position))
                 continue;
+            SemanticType actual;
             if (providesExpectedTypes && formalByPosition[position] is { } positionalFormal)
-                _expectedType = positionalFormal is UnknownType ? null : positionalFormal;
-            var actual = CheckExpression(call.Arguments[position]);
-            _expectedType = previousExpectedType;
+            {
+                using (EnterStore(StorePosition.LambdaParameterDefault, positionalFormal, call.Arguments[position]))
+                    actual = CheckExpression(call.Arguments[position]);
+            }
+            else
+            {
+                actual = CheckExpression(call.Arguments[position]);
+            }
             positionTypes[position] = actual;
             if (formalByPosition[position] is { } formal)
             {
@@ -298,10 +304,16 @@ private bool TryCheckDeferredLambdaArguments(
         {
             if (deferredKeywords.Contains(kwarg.Name))
                 continue;
+            SemanticType actual;
             if (providesExpectedTypes && formalByKeyword.TryGetValue(kwarg.Name, out var keywordFormal))
-                _expectedType = keywordFormal is UnknownType ? null : keywordFormal;
-            var actual = CheckExpression(kwarg.Value);
-            _expectedType = previousExpectedType;
+            {
+                using (EnterStore(StorePosition.LambdaParameterDefault, keywordFormal, kwarg.Value))
+                    actual = CheckExpression(kwarg.Value);
+            }
+            else
+            {
+                actual = CheckExpression(kwarg.Value);
+            }
             kwargTypes[kwarg.Name] = actual;
             if (formalByKeyword.TryGetValue(kwarg.Name, out var boundFormal))
             {
@@ -344,8 +356,9 @@ private bool TryCheckDeferredLambdaArguments(
         {
             var formal = formalByPosition[position]!;
             SemanticType checkedType;
-            using (ScopedValue.Push(ref _expectedType,
-                       SubstituteExpectedLambdaType(formal, substitutions) ?? previousExpectedType))
+            using (EnterStore(StorePosition.LambdaBody,
+                       SubstituteExpectedLambdaType(formal, substitutions) ?? previousExpectedType ?? SemanticType.Unknown,
+                       call.Arguments[position]))
             {
                 checkedType = CheckExpression(call.Arguments[position]);
             }
@@ -359,8 +372,9 @@ private bool TryCheckDeferredLambdaArguments(
 
             var keywordFormal = formalByKeyword[kwarg.Name];
             SemanticType checkedType;
-            using (ScopedValue.Push(ref _expectedType,
-                       SubstituteExpectedLambdaType(keywordFormal, substitutions) ?? previousExpectedType))
+            using (EnterStore(StorePosition.LambdaBody,
+                       SubstituteExpectedLambdaType(keywordFormal, substitutions) ?? previousExpectedType ?? SemanticType.Unknown,
+                       kwarg.Value))
             {
                 checkedType = CheckExpression(kwarg.Value);
             }