Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Fixed declaration emit crash related to enum entity name expressions #58786

Merged
merged 6 commits into from
Jun 13, 2024
Merged
Show file tree
Hide file tree
Changes from 5 commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 14 additions & 2 deletions src/compiler/checker.ts
Original file line number Diff line number Diff line change
Expand Up @@ -8856,8 +8856,20 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
else {
const type = getWidenedType(getRegularTypeOfExpression(node.expression));
const computedPropertyNameType = typeToTypeNodeHelper(type, context);
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

this can return ImportType in the enum's case, that's the reason why it crashed - the code here assumed that a literal type node would always be returned but that wasn't true

Debug.assertNode(computedPropertyNameType, isLiteralTypeNode);
const literal = computedPropertyNameType.literal;
let literal;
if (isLiteralTypeNode(computedPropertyNameType)) {
literal = computedPropertyNameType.literal;
}
else {
const evaluated = evaluateEntityNameExpression(node.expression);
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

the result of this matches the 5.4 behavior, that's why I've reached for evaluating this but perhaps there are reasons why this is wrong

const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral(evaluated.value, /*isSingleQuote*/ undefined) :
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

creating those objects is wasteful here but it feels like it keeps the code cleaner, I can change this if you request that change

typeof evaluated.value === "number" ? factory.createNumericLiteral(evaluated.value, /*numericLiteralFlags*/ 0) :
undefined;
if (!literalNode) {
Copy link
Member

@weswigham weswigham Jun 6, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't think this assertion is legit - unless you make assumptions about the computed property name being "correct" in some way, its' expression could resolve to any type (as the issue prompting this showed). Notably, evaluateEntityNameExpression will just return undefined if the entity name doesn't resolve (or resolves to a non-literal), which'll in turn trigger this assertion. In such a case, we probably want to retain the whole computed name as-is, but mark an error?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I couldn't cause a crash using invalid computed property names but I managed to find a crashing case with symbols. Could you take another look?

return node;
}
literal = literalNode;
}
if (literal.kind === SyntaxKind.StringLiteral && isIdentifierText(literal.text, getEmitScriptTarget(compilerOptions))) {
return factory.createIdentifier(literal.text);
}
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum1.ts] ////

//// [type.ts]
export enum Enum {
A = "a",
B = "b"
}

export type Type = { x?: { [Enum.A]: 0 } };

//// [index.ts]
import { type Type } from "./type";

export const foo = { ...({} as Type) };




//// [type.d.ts]
export declare enum Enum {
A = "a",
B = "b"
}
export type Type = {
x?: {
[Enum.A]: 0;
};
};
//// [index.d.ts]
export declare const foo: {
x?: {
a: 0;
};
};
Original file line number Diff line number Diff line change
@@ -0,0 +1,29 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum1.ts] ////

=== type.ts ===
export enum Enum {
>Enum : Symbol(Enum, Decl(type.ts, 0, 0))

A = "a",
>A : Symbol(Enum.A, Decl(type.ts, 0, 18))

B = "b"
>B : Symbol(Enum.B, Decl(type.ts, 1, 10))
}

export type Type = { x?: { [Enum.A]: 0 } };
>Type : Symbol(Type, Decl(type.ts, 3, 1))
>x : Symbol(x, Decl(type.ts, 5, 20))
>[Enum.A] : Symbol([Enum.A], Decl(type.ts, 5, 26))
>Enum.A : Symbol(Enum.A, Decl(type.ts, 0, 18))
>Enum : Symbol(Enum, Decl(type.ts, 0, 0))
>A : Symbol(Enum.A, Decl(type.ts, 0, 18))

=== index.ts ===
import { type Type } from "./type";
>Type : Symbol(Type, Decl(index.ts, 0, 8))

export const foo = { ...({} as Type) };
>foo : Symbol(foo, Decl(index.ts, 2, 12))
>Type : Symbol(Type, Decl(index.ts, 0, 8))

Original file line number Diff line number Diff line change
@@ -0,0 +1,51 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum1.ts] ////

=== type.ts ===
export enum Enum {
>Enum : Enum
> : ^^^^

A = "a",
>A : Enum.A
> : ^^^^^^
>"a" : "a"
> : ^^^

B = "b"
>B : Enum.B
> : ^^^^^^
>"b" : "b"
> : ^^^
}

export type Type = { x?: { [Enum.A]: 0 } };
>Type : Type
> : ^^^^
>x : { a: 0; } | undefined
> : ^^^^^ ^^^^^^^^^^^^^^^
>[Enum.A] : 0
> : ^
>Enum.A : Enum.A
> : ^^^^^^
>Enum : typeof Enum
> : ^^^^^^^^^^^
>A : Enum.A
> : ^^^^^^

=== index.ts ===
import { type Type } from "./type";
>Type : any
> : ^^^

export const foo = { ...({} as Type) };
>foo : { x?: { a: 0; }; }
> : ^^^^^^ ^^^
>{ ...({} as Type) } : { x?: { a: 0; }; }
> : ^^^^^^ ^^^
>({} as Type) : Type
> : ^^^^
>{} as Type : Type
> : ^^^^
>{} : {}
> : ^^

Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
type.ts(1,28): error TS1170: A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
type.ts(1,29): error TS2304: Cannot find name 'Enum'.


==== type.ts (2 errors) ====
export type Type = { x?: { [Enum.A]: 0 } };
~~~~~~~~
!!! error TS1170: A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
~~~~
!!! error TS2304: Cannot find name 'Enum'.

==== index.ts (0 errors) ====
import { type Type } from "./type";

export const foo = { ...({} as Type) };

Original file line number Diff line number Diff line change
@@ -0,0 +1,23 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum2.ts] ////

//// [type.ts]
export type Type = { x?: { [Enum.A]: 0 } };

//// [index.ts]
import { type Type } from "./type";

export const foo = { ...({} as Type) };




//// [type.d.ts]
export type Type = {
x?: {};
};
//// [index.d.ts]
export declare const foo: {
x?: {
[Enum.A]: 0;
};
};
Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum2.ts] ////

=== type.ts ===
export type Type = { x?: { [Enum.A]: 0 } };
>Type : Symbol(Type, Decl(type.ts, 0, 0))
>x : Symbol(x, Decl(type.ts, 0, 20))
>[Enum.A] : Symbol([Enum.A], Decl(type.ts, 0, 26))

=== index.ts ===
import { type Type } from "./type";
>Type : Symbol(Type, Decl(index.ts, 0, 8))

export const foo = { ...({} as Type) };
>foo : Symbol(foo, Decl(index.ts, 2, 12))
>Type : Symbol(Type, Decl(index.ts, 0, 8))

Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum2.ts] ////

=== type.ts ===
export type Type = { x?: { [Enum.A]: 0 } };
>Type : Type
> : ^^^^
>x : {} | undefined
> : ^^^^^^^^^^^^^^
>[Enum.A] : 0
> : ^
>Enum.A : any
> : ^^^
>Enum : any
> : ^^^
>A : any
> : ^^^

=== index.ts ===
import { type Type } from "./type";
>Type : any
> : ^^^

export const foo = { ...({} as Type) };
>foo : { x?: { [Enum.A]: 0; }; }
> : ^^^^^^ ^^^
>{ ...({} as Type) } : { x?: { [Enum.A]: 0; }; }
> : ^^^^^^ ^^^
>({} as Type) : Type
> : ^^^^
>{} as Type : Type
> : ^^^^
>{} : {}
> : ^^

Original file line number Diff line number Diff line change
@@ -0,0 +1,22 @@
type.ts(7,28): error TS1170: A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
type.ts(7,28): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.


==== type.ts (2 errors) ====
export namespace Foo {
export enum Enum {
A = "a",
B = "b",
}
}
export type Type = { x?: { [Foo.Enum]: 0 } };
~~~~~~~~~~
!!! error TS1170: A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
~~~~~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.

==== index.ts (0 errors) ====
import { type Type } from "./type";

export const foo = { ...({} as Type) };

Original file line number Diff line number Diff line change
@@ -0,0 +1,33 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum3.ts] ////

//// [type.ts]
export namespace Foo {
export enum Enum {
A = "a",
B = "b",
}
}
export type Type = { x?: { [Foo.Enum]: 0 } };

//// [index.ts]
import { type Type } from "./type";

export const foo = { ...({} as Type) };




//// [type.d.ts]
export declare namespace Foo {
enum Enum {
A = "a",
B = "b"
}
}
export type Type = {
x?: {};
};
//// [index.d.ts]
export declare const foo: {
x?: {};
};
Original file line number Diff line number Diff line change
@@ -0,0 +1,32 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum3.ts] ////

=== type.ts ===
export namespace Foo {
>Foo : Symbol(Foo, Decl(type.ts, 0, 0))

export enum Enum {
>Enum : Symbol(Enum, Decl(type.ts, 0, 22))

A = "a",
>A : Symbol(Enum.A, Decl(type.ts, 1, 20))

B = "b",
>B : Symbol(Enum.B, Decl(type.ts, 2, 12))
}
}
export type Type = { x?: { [Foo.Enum]: 0 } };
>Type : Symbol(Type, Decl(type.ts, 5, 1))
>x : Symbol(x, Decl(type.ts, 6, 20))
>[Foo.Enum] : Symbol([Foo.Enum], Decl(type.ts, 6, 26))
>Foo.Enum : Symbol(Foo.Enum, Decl(type.ts, 0, 22))
>Foo : Symbol(Foo, Decl(type.ts, 0, 0))
>Enum : Symbol(Foo.Enum, Decl(type.ts, 0, 22))

=== index.ts ===
import { type Type } from "./type";
>Type : Symbol(Type, Decl(index.ts, 0, 8))

export const foo = { ...({} as Type) };
>foo : Symbol(foo, Decl(index.ts, 2, 12))
>Type : Symbol(Type, Decl(index.ts, 0, 8))

Original file line number Diff line number Diff line change
@@ -0,0 +1,55 @@
//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum3.ts] ////

=== type.ts ===
export namespace Foo {
>Foo : typeof Foo
> : ^^^^^^^^^^

export enum Enum {
>Enum : Enum
> : ^^^^

A = "a",
>A : Enum.A
> : ^^^^^^
>"a" : "a"
> : ^^^

B = "b",
>B : Enum.B
> : ^^^^^^
>"b" : "b"
> : ^^^
}
}
export type Type = { x?: { [Foo.Enum]: 0 } };
>Type : Type
> : ^^^^
>x : {} | undefined
> : ^^^^^^^^^^^^^^
>[Foo.Enum] : 0
> : ^
>Foo.Enum : typeof Foo.Enum
> : ^^^^^^^^^^^^^^^
>Foo : typeof Foo
> : ^^^^^^^^^^
>Enum : typeof Foo.Enum
> : ^^^^^^^^^^^^^^^

=== index.ts ===
import { type Type } from "./type";
>Type : any
> : ^^^

export const foo = { ...({} as Type) };
>foo : { x?: {}; }
> : ^^^^^^ ^^^
>{ ...({} as Type) } : { x?: {}; }
> : ^^^^^^ ^^^
>({} as Type) : Type
> : ^^^^
>{} as Type : Type
> : ^^^^
>{} : {}
> : ^^

Loading