Freshness may be gone, but we still need refinement filtering on mutable location assignment

Author: weswigham

tsc/internal/checker/checker.go

@@ -17377,7 +17377,10 @@ func (c *Checker) getWidenedLiteralTypeForInitializer(declaration *ast.Node, t *
 	if c.getCombinedNodeFlagsCached(declaration)&ast.NodeFlagsConstant != 0 || isDeclarationReadonly(declaration) {
 		return t
 	}
-	return c.getWidenedLiteralType(t)
+	if initializer := declaration.Initializer(); initializer != nil && isTypeAssertion(ast.SkipOuterExpressions(initializer, ast.OEKParentheses|ast.OEKNonNullAssertions|ast.OEKSatisfies)) {
+		return c.getWidenedLiteralType(t)
+	}
+	return c.getWidenedNegatedLiteralType(c.getWidenedLiteralType(t))
 }
 
 func (c *Checker) getTypeOfFuncClassEnumModule(symbol *ast.Symbol) *Type {
@@ -21230,7 +21233,7 @@ func (c *Checker) checkIfExpressionRefinesParameter(fn *ast.Node, expr *ast.Node
 		antecedent = &ast.FlowNode{Flags: ast.FlowFlagsStart}
 	}
 	trueCondition := &ast.FlowNode{Flags: ast.FlowFlagsTrueCondition, Node: expr, Antecedent: antecedent}
-	trueType := c.getFlowTypeOfReferenceEx(param.Name(), initType, initType, fn, trueCondition)
+	trueType := c.getWidenedNegatedLiteralType(c.getFlowTypeOfReferenceEx(param.Name(), initType, initType, fn, trueCondition))
 	if trueType == initType {
 		return nil
 	}

tsc/internal/checker/checker_test.go

@@ -171,7 +171,8 @@ func BenchmarkCheckFreshProgram(b *testing.B) {
 		program.BindSourceFiles()
 		c, _ := checker.NewChecker(program, nil)
 		for _, file := range program.GetSourceFiles() {
-			assert.Equal(b, len(c.GetDiagnostics(ctx, file)), 0)
+			diagnostics := c.GetDiagnostics(ctx, file)
+			assert.Check(b, len(diagnostics) == 0, "%s: %v", file.FileName(), diagnostics)
 		}
 		assert.Equal(b, len(c.GetGlobalDiagnostics()), 0)
 	}

tsc/internal/checker/flow.go

@@ -240,6 +240,14 @@ func (c *Checker) getTypeAtFlowAssignment(f *FlowState, flow *ast.FlowNode) Flow
 				flowType := c.getTypeAtFlowNode(f, flow.Antecedent)
 				return c.newFlowType(c.getBaseTypeOfLiteralType(flowType.t), flowType.incomplete)
 			}
+			if c.maybeTypeOfKind(f.declaredType, TypeFlagsNullable) {
+				flowType := c.getTypeAtFlowNode(f, flow.Antecedent)
+				t := c.filterType(f.declaredType, func(t *Type) bool {
+					return t.flags&TypeFlagsNullable == 0 ||
+						c.hasTypeFacts(flowType.t, core.IfElse(t.flags&TypeFlagsUndefined != 0, TypeFactsEQUndefined, TypeFactsEQNull))
+				})
+				return c.newFlowType(t, flowType.incomplete)
+			}
 			return FlowType{t: f.declaredType}
 		}
 		if f.declaredType == c.autoType || f.declaredType == c.autoArrayType {

tsc/internal/checker/negated.go

@@ -59,6 +59,24 @@ func containsNegatedType(t *Type) bool {
 	return false
 }
 
+// Literal exclusions must not make inferred mutable locations narrower than their primitive types.
+func (c *Checker) getWidenedNegatedLiteralType(t *Type) *Type {
+	switch {
+	case t.flags&TypeFlagsNegated != 0:
+		if t.AsNegatedType().baseType.flags&TypeFlagsLiteral != 0 {
+			return c.unknownType
+		}
+	case t.flags&TypeFlagsUnion != 0:
+		return c.mapType(t, c.getWidenedNegatedLiteralType)
+	case t.flags&TypeFlagsIntersection != 0:
+		types := core.SameMap(t.Types(), c.getWidenedNegatedLiteralType)
+		if !slices.Equal(types, t.Types()) {
+			return c.getIntersectionType(types)
+		}
+	}
+	return t
+}
+
 // removeComplementaryNegatedTypes replaces 'Base & not C' with 'Base' when another branch covers
 // 'Base & C'. That branch is retained unless it is also contained in Base. Removing one negation
 // at a time preserves shared negative factors and allows successive reductions, for example

tsc/testdata/baselines/reference/compiler/compoundAssignmentPreservesNullableNarrowing.errors.txt

@@ -0,0 +1,154 @@
+compoundAssignmentPreservesNullableNarrowing.ts(99,5): error TS18049: 'value' is possibly 'null' or 'undefined'.
+compoundAssignmentPreservesNullableNarrowing.ts(100,5): error TS18049: 'value' is possibly 'null' or 'undefined'.
+compoundAssignmentPreservesNullableNarrowing.ts(101,11): error TS2322: Type 'number | null | undefined' is not assignable to type 'number'.
+  Type 'undefined' is not assignable to type 'number'.
+compoundAssignmentPreservesNullableNarrowing.ts(107,9): error TS18048: 'value' is possibly 'undefined'.
+compoundAssignmentPreservesNullableNarrowing.ts(109,15): error TS2322: Type 'number | undefined' is not assignable to type 'number'.
+  Type 'undefined' is not assignable to type 'number'.
+compoundAssignmentPreservesNullableNarrowing.ts(117,9): error TS18047: 'value' is possibly 'null'.
+compoundAssignmentPreservesNullableNarrowing.ts(119,15): error TS2322: Type 'number | null' is not assignable to type 'number'.
+  Type 'null' is not assignable to type 'number'.
+
+
+==== compoundAssignmentPreservesNullableNarrowing.ts (7 errors) ====
+    enum Flags {
+        None = 0,
+        First = 1,
+        Second = 2,
+    }
+    
+    export function enumFlags(value: Flags | undefined) {
+        if (value === undefined) {
+            value = Flags.None;
+            value |= Flags.First;
+            value |= Flags.Second;
+        }
+        const result: Flags = value;
+        return value;
+    }
+    
+    export function numeric(value: number | null | undefined) {
+        if (value != null) {
+            value -= 1;
+            value += 1;
+            value *= 2;
+            value /= 2;
+            value %= 2;
+            value **= 2;
+            value <<= 1;
+            value >>= 1;
+            value >>>= 1;
+            value |= 1;
+            value &= 1;
+            value ^= 1;
+            const result: number = value;
+            return value;
+        }
+        throw new Error();
+    }
+    
+    export function updates(value: number | null | undefined) {
+        if (value != null) {
+            value++;
+            ++value;
+            value--;
+            --value;
+            const result: number = value;
+            return value;
+        }
+        throw new Error();
+    }
+    
+    export function bigint(value: bigint | null | undefined) {
+        if (value != null) {
+            value *= 2n;
+            value++;
+            const result: bigint = value;
+            return value;
+        }
+        throw new Error();
+    }
+    
+    export function text(value: string | null | undefined) {
+        if (value != null) {
+            value += "suffix";
+            const result: string = value;
+            return value;
+        }
+        throw new Error();
+    }
+    
+    export function properties(holder: { value?: number | null }) {
+        if (holder.value != null) {
+            holder.value -= 1;
+            holder["value"]++;
+            const result: number = holder.value;
+            return holder["value"];
+        }
+        throw new Error();
+    }
+    
+    export function loop(value: number | null | undefined) {
+        if (value != null) {
+            while (value !== 0) {
+                value -= 1;
+            }
+            const result: 0 = value;
+            return value;
+        }
+        throw new Error();
+    }
+    
+    export function mutableFlags(value: number, flags: number[]) {
+        if (value === 0) return "";
+        let remainingFlags: number = value;
+        for (const flag of flags) {
+            remainingFlags &= ~flag;
+        }
+        return remainingFlags === 0 ? "all" : "some";
+    }
+    
+    export function unchecked(value: number | null | undefined) {
+        value -= 1;
+        ~~~~~
+!!! error TS18049: 'value' is possibly 'null' or 'undefined'.
+        value++;
+        ~~~~~
+!!! error TS18049: 'value' is possibly 'null' or 'undefined'.
+        const result: number = value;
+              ~~~~~~
+!!! error TS2322: Type 'number | null | undefined' is not assignable to type 'number'.
+!!! error TS2322:   Type 'undefined' is not assignable to type 'number'.
+        return value;
+    }
+    
+    export function checkedOnlyNull(value: number | null | undefined) {
+        if (value !== null) {
+            value -= 1;
+            ~~~~~
+!!! error TS18048: 'value' is possibly 'undefined'.
+            const result: number | undefined = value;
+            const invalid: number = value;
+                  ~~~~~~~
+!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'.
+!!! error TS2322:   Type 'undefined' is not assignable to type 'number'.
+            return value;
+        }
+        throw new Error();
+    }
+    
+    export function checkedOnlyUndefined(value: number | null | undefined) {
+        if (value !== undefined) {
+            value -= 1;
+            ~~~~~
+!!! error TS18047: 'value' is possibly 'null'.
+            const result: number | null = value;
+            const invalid: number = value;
+                  ~~~~~~~
+!!! error TS2322: Type 'number | null' is not assignable to type 'number'.
+!!! error TS2322:   Type 'null' is not assignable to type 'number'.
+            return value;
+        }
+        throw new Error();
+    }
+