fix(checker): suppress false TS7008 for empty array assigned to annotated expando property

[Zelys-DFKH]

Fixes #3976

Credit to @chriskrycho, who traced the regression to #3680 and the exact nightly in the bug report. That diagnosis was the map.

Analysis

Callable-type variables with expando property assignments like fn.items = [] were incorrectly producing TS7008 ("Member 'items' implicitly has an 'any[]' type") even when fn carries an explicit type annotation that declares the property.

The root cause is a circular type resolution path. When getAssignmentDeclarationInitializerType evaluates fn.items = [], it calls checkExpressionForMutableLocation on the [] RHS. That function tries to establish a contextual type by resolving fn.items, which requires computing the type of the assignment declaration — which is the function we're currently in. The circularity causes [] to resolve as never[] instead of string[]. The existing isEmptyArrayLiteralType check then sees never[] and fires TS7008.

For plain object variables (const obj: { tags?: string[] } = {}), this doesn't occur because the binder doesn't create an assignment declaration symbol for that case (plain objects aren't expando initializers in TS mode).

Fix

Added getPropertyTypeFromContainerAnnotation, a helper called before the TS7008 diagnostic fires. It navigates through the AST to the explicit type annotation on the container variable — bypassing the circular resolution path entirely — and looks up the declared property type. If an annotation covers the property, that type is returned directly and TS7008 is skipped.

The navigation path for const fn: T = () => undefined; fn.items = []:

1. getSymbolOfNode(binaryExpr) → items symbol (set by the binder on the assignment declaration)
2. .Parent → the arrow function's symbol
3. .ValueDeclaration → the arrow function node
4. .Parent (AST) → the VariableDeclaration carrying the explicit type annotation
5. tryGetTypeFromTypeNode(varDecl) → reads the annotation type without triggering inference
6. getPropertyOfType(containerType, "items") + getWriteTypeOfSymbol(prop) → the write type of the property (for optional properties: string[], not string[] | missing; for accessor properties: the setter type)

If any step returns nil (no annotation, wrong declaration shape, etc.), the helper returns nil and TS7008 fires as before. This preserves the diagnostic for genuinely untyped cases like const fn3 = () => undefined; fn3.labels = [].

Second commit: Under exactOptionalPropertyTypes, optional properties carry an internal missing type that getTypeOfSymbol returns raw. Changed to getWriteTypeOfSymbol, which strips it via removeMissingType: the right behavior for any assignment-context type lookup. Added a compiler test with // @exactOptionalPropertyTypes: true covering both annotated containers (no error) and the unannotated control (TS7008 still fires).

Regression introduced by #3680.

Copilot Checklist

I successfully ran these commands at the end of my session, and they completed without error:

• npx hereby build
• npx hereby test
• npx hereby lint
• npx hereby format

[Copilot]

Pull request overview

Fixes a checker regression where expando assignments like fn.items = [] on callable-typed variables incorrectly triggered TS7008 even when the container variable has an explicit type annotation that declares the property.

Changes:

• Updates assignment-declaration initializer typing to suppress TS7008 for empty-array RHS when the container’s explicit annotation provides a declared property type.
• Adds a checker helper to retrieve the property type directly from the container variable’s type annotation to avoid circular type resolution.
• Adds a compiler test case and reference baselines covering callable-type and object-type annotated containers, plus an unannotated control that should still error.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
internal/checker/checker.go	Adds annotation-based property type lookup to bypass circular resolution and avoid false TS7008 on empty-array expando assignments.
testdata/tests/cases/compiler/callableTypePropertyEmptyArrayAssignment.ts	New regression test for TS7008 suppression with annotated callable/object containers and a failing unannotated case.
testdata/baselines/reference/compiler/callableTypePropertyEmptyArrayAssignment.types	Reference types baseline for the new test.
testdata/baselines/reference/compiler/callableTypePropertyEmptyArrayAssignment.symbols	Reference symbols baseline for the new test.
testdata/baselines/reference/compiler/callableTypePropertyEmptyArrayAssignment.errors.txt	Reference errors baseline ensuring TS7008 still occurs for the unannotated case.

[Zelys-DFKH]

Good catch. This is an assignment context, and getWriteTypeOfSymbol is the canonical choice here. It calls removeMissingType for optional properties, which strips the internal missing type under exactOptionalPropertyTypes. Downstream assignability checking then sees string[] instead of string[] | missing. It also uses the setter type for accessor properties, which is semantically correct when writing. Added a compiler test with // @exactOptionalPropertyTypes: true to explicitly cover this path.

[ahejlsberg]

@Zelys-DFKH Appreciate the effort, but I have a simpler fix in #3986.

[Zelys-DFKH]

Thanks for the review, @ahejlsberg. I went the long way around, re-deriving through the AST what symbol.Parent already captures, which is exactly why mine needed the PropertyAccessExpression guard and yours didn't. Good lesson in starting from the right layer.