fix(checker): Allow element access expressions in computed property names if argument is literal

[kairosci]

Fixes #25083.

This PR relaxes the check for computed property names in type literals (specifically in isLateBindableAST) to allow ElementAccessExpression when the argument is a static literal.

Changes

Checker (src/compiler/checker.ts)

• Updated isLateBindableAST to use a new helper isLateBindableExpression.
• isLateBindableExpression recursively checks the expression and allows:
  • String literals (e.g., Enum['key'])
  • Numeric literals
  • Signed numeric literals (e.g., Enum[-1])
  • Parenthesized expressions (e.g., Enum[('key')])

Utilities (src/compiler/utilities.ts)

• Updated isComputedNonLiteralName to also check for isSignedNumericLiteral
• Updated tryGetTextOfPropertyName to handle signed numeric literals in ComputedPropertyName, aligning with getPropertyNameForPropertyNameNode

Example

enum Type {
  '3x14' = '3x14'
}
enum Numeric {
    Negative = -1,
}

type TypeMap = {
  [Type['3x14']]: any;       // Now valid
  [Numeric['Negative']]: any; // Now valid
  [Numeric[('Negative')]]: any; // Now valid
}

Verified with new test case tests/cases/compiler/enumKeysInTypeLiteral.ts covering these scenarios.

[Copilot]

Pull request overview

This PR fixes issue #25083 by allowing element access expressions (e.g., Enum['key']) as computed property names in type literals when the argument is a literal. Previously, only dot notation (e.g., Enum.key) was accepted for enum members in computed property names.

Changes:

• Modified isLateBindableAST to use a new helper isLateBindableExpression that recursively validates element access chains with literal arguments
• Updated utility functions to handle signed numeric literals in computed property names
• Added test case covering enum keys accessed via bracket notation in type literals

Reviewed changes

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

Show a summary per file

File	Description
tests/cases/compiler/enumKeysInTypeLiteral.ts	New test case demonstrating enum element access with bracket notation in type literals
tests/baselines/reference/enumKeysInTypeLiteral.*	Baseline files for the new test showing expected types, symbols, and JS output
tests/baselines/reference/isolatedDeclarationLazySymbols.*	Updated baselines reflecting improved type inference for element access expressions
src/compiler/checker.ts	Added isLateBindableExpression helper and modified isLateBindableAST to handle element access chains
src/compiler/utilities.ts	Updated isComputedNonLiteralName and tryGetTextOfPropertyName to handle signed numeric literals; formatting improvements

[Copilot]

The logic for handling ElementAccessExpression is incorrect. When node is an ElementAccessExpression (e.g., Type['key']), this code passes only node.argumentExpression (which would be the literal 'key') to isLateBindableExpression.

However, isLateBindableExpression expects to validate the full expression chain. When passed a literal like 'key', it skips the while loop (since a literal is not an ElementAccessExpression) and calls isEntityNameExpression('key'), which returns false because a string literal is not an entity name expression.

The correct approach is to pass the entire node to isLateBindableExpression, not just node.argumentExpression. This would allow the function to properly validate the element access chain and then check that the base is an entity name expression.