Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Widening and non-widening computed enum types (#52542)

Browse Source
This commit is contained in:
Anders Hejlsberg
2023-02-14 16:25:46 -08:00
committed by GitHub
parent de2ab4ab8f
commit 7d00bb078d
22 changed files with 980 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/checker.ts
+31 -20
View File
@@ -157,6 +157,7 @@ import {
entityNameToString,
EnumDeclaration,
EnumMember,
EnumType,
equateValues,
escapeLeadingUnderscores,
escapeString,
@@ -9660,8 +9661,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const t = types[i];
flags |= t.flags;
if (!(t.flags & TypeFlags.Nullable)) {
if (t.flags & (TypeFlags.BooleanLiteral | TypeFlags.EnumLiteral)) {
const baseType = t.flags & TypeFlags.BooleanLiteral ? booleanType : getBaseTypeOfEnumLiteralType(t as LiteralType);
if (t.flags & (TypeFlags.BooleanLiteral | TypeFlags.EnumLike)) {
const baseType = t.flags & TypeFlags.BooleanLiteral ? booleanType : getBaseTypeOfEnumLikeType(t as LiteralType);
if (baseType.flags & TypeFlags.Union) {
const count = (baseType as UnionType).types.length;
if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType((baseType as UnionType).types[count - 1])) {
@@ -11906,8 +11907,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
return links.declaredType;
}
function getBaseTypeOfEnumLiteralType(type: Type) {
return type.flags & TypeFlags.EnumLiteral && !(type.flags & TypeFlags.Union) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)!) : type;
function getBaseTypeOfEnumLikeType(type: Type) {
return type.flags & TypeFlags.EnumLike && type.symbol.flags & SymbolFlags.EnumMember ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)!) : type;
}
function getDeclaredTypeOfEnum(symbol: Symbol): Type {
@@ -11921,9 +11922,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (hasBindableName(member)) {
const memberSymbol = getSymbolOfDeclaration(member);
const value = getEnumMemberValue(member);
const memberType = value !== undefined ?
getFreshTypeOfLiteralType(getEnumLiteralType(value, getSymbolId(symbol), memberSymbol)) :
createTypeWithSymbol(TypeFlags.Enum, memberSymbol);
const memberType = getFreshTypeOfLiteralType(value !== undefined ?
getEnumLiteralType(value, getSymbolId(symbol), memberSymbol) :
createComputedEnumType(memberSymbol));
getSymbolLinks(memberSymbol).declaredType = memberType;
memberTypeList.push(getRegularTypeOfLiteralType(memberType));
}
@@ -11933,7 +11934,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
const enumType = memberTypeList.length ?
getUnionType(memberTypeList, UnionReduction.Literal, symbol, /*aliasTypeArguments*/ undefined) :
createTypeWithSymbol(TypeFlags.Enum, symbol);
createComputedEnumType(symbol);
if (enumType.flags & TypeFlags.Union) {
enumType.flags |= TypeFlags.EnumLiteral;
enumType.symbol = symbol;
@@ -11943,6 +11944,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
return links.declaredType;
}
function createComputedEnumType(symbol: Symbol) {
const regularType = createTypeWithSymbol(TypeFlags.Enum, symbol) as EnumType;
const freshType = createTypeWithSymbol(TypeFlags.Enum, symbol) as EnumType;
regularType.regularType = regularType;
regularType.freshType = freshType;
freshType.regularType = regularType;
freshType.freshType = freshType;
return regularType;
}
function getDeclaredTypeOfEnumMember(symbol: Symbol): Type {
const links = getSymbolLinks(symbol);
if (!links.declaredType) {
@@ -16201,7 +16212,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
orderedRemoveItemAt(typeSet, 1);
}
}
if (includes & (TypeFlags.Literal | TypeFlags.UniqueESSymbol | TypeFlags.TemplateLiteral | TypeFlags.StringMapping) || includes & TypeFlags.Void && includes & TypeFlags.Undefined) {
if (includes & (TypeFlags.Enum | TypeFlags.Literal | TypeFlags.UniqueESSymbol | TypeFlags.TemplateLiteral | TypeFlags.StringMapping) || includes & TypeFlags.Void && includes & TypeFlags.Undefined) {
removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & UnionReduction.Subtype));
}
if (includes & TypeFlags.StringLiteral && includes & TypeFlags.TemplateLiteral) {
@@ -18046,25 +18057,25 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
function getFreshTypeOfLiteralType(type: Type): Type {
if (type.flags & TypeFlags.Literal) {
if (!(type as LiteralType).freshType) {
if (type.flags & TypeFlags.Freshable) {
if (!(type as FreshableType).freshType) {
const freshType = createLiteralType(type.flags, (type as LiteralType).value, (type as LiteralType).symbol, type as LiteralType);
freshType.freshType = freshType;
(type as LiteralType).freshType = freshType;
(type as FreshableType).freshType = freshType;
}
return (type as LiteralType).freshType;
return (type as FreshableType).freshType;
}
return type;
}
function getRegularTypeOfLiteralType(type: Type): Type {
return type.flags & TypeFlags.Literal ? (type as LiteralType).regularType :
return type.flags & TypeFlags.Freshable ? (type as FreshableType).regularType :
type.flags & TypeFlags.Union ? ((type as UnionType).regularType || ((type as UnionType).regularType = mapType(type, getRegularTypeOfLiteralType) as UnionType)) :
type;
}
function isFreshLiteralType(type: Type) {
return !!(type.flags & TypeFlags.Literal) && (type as LiteralType).freshType === type;
return !!(type.flags & TypeFlags.Freshable) && (type as LiteralType).freshType === type;
}
function getStringLiteralType(value: string): StringLiteralType {
@@ -22993,7 +23004,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
function getBaseTypeOfLiteralType(type: Type): Type {
return type.flags & TypeFlags.EnumLiteral ? getBaseTypeOfEnumLiteralType(type as LiteralType) :
return type.flags & TypeFlags.EnumLike ? getBaseTypeOfEnumLikeType(type as LiteralType) :
type.flags & (TypeFlags.StringLiteral | TypeFlags.TemplateLiteral | TypeFlags.StringMapping) ? stringType :
type.flags & TypeFlags.NumberLiteral ? numberType :
type.flags & TypeFlags.BigIntLiteral ? bigintType :
@@ -23008,7 +23019,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
function getWidenedLiteralType(type: Type): Type {
return type.flags & TypeFlags.EnumLiteral && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type as LiteralType) :
return type.flags & TypeFlags.EnumLike && isFreshLiteralType(type) ? getBaseTypeOfEnumLikeType(type as LiteralType) :
type.flags & TypeFlags.StringLiteral && isFreshLiteralType(type) ? stringType :
type.flags & TypeFlags.NumberLiteral && isFreshLiteralType(type) ? numberType :
type.flags & TypeFlags.BigIntLiteral && isFreshLiteralType(type) ? bigintType :
@@ -25652,7 +25663,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
return true;
}
if (source.flags & TypeFlags.EnumLiteral && getBaseTypeOfEnumLiteralType(source as LiteralType) === target) {
if (source.flags & TypeFlags.EnumLike && getBaseTypeOfEnumLikeType(source as LiteralType) === target) {
return true;
}
return containsType(target.types, source);
@@ -45995,7 +46006,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
const enumResult = type.flags & TypeFlags.EnumLiteral ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing, /*flags*/ undefined, tracker)
const enumResult = type.flags & TypeFlags.EnumLike ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing, /*flags*/ undefined, tracker)
: type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
if (enumResult) return enumResult;
const literalValue = (type as LiteralType).value;
@@ -47782,7 +47793,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
function isSimpleLiteralEnumReference(expr: Expression) {
if ((isPropertyAccessExpression(expr) || (isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression))) &&
isEntityNameExpression(expr.expression)) {
return !!(checkExpressionCached(expr).flags & TypeFlags.EnumLiteral);
return !!(checkExpressionCached(expr).flags & TypeFlags.EnumLike);
}
}
src/compiler/types.ts
+9 -10
View File
@@ -6043,7 +6043,8 @@ export const enum TypeFlags {
/** @internal */
Nullable = Undefined | Null,
Literal = StringLiteral | NumberLiteral | BigIntLiteral | BooleanLiteral,
Unit = Literal | UniqueESSymbol | Nullable,
Unit = Enum | Literal | UniqueESSymbol | Nullable,
Freshable = Enum | Literal,
StringOrNumberLiteral = StringLiteral | NumberLiteral,
/** @internal */
StringOrNumberLiteralOrUnique = StringLiteral | NumberLiteral | UniqueESSymbol,
@@ -6137,22 +6138,20 @@ export interface NullableType extends IntrinsicType {
objectFlags: ObjectFlags;
}
/** @internal */
export interface FreshableIntrinsicType extends IntrinsicType {
freshType: IntrinsicType; // Fresh version of type
regularType: IntrinsicType; // Regular version of type
export interface FreshableType extends Type {
freshType: FreshableType; // Fresh version of type
regularType: FreshableType; // Regular version of type
}
/** @internal */
export type FreshableType = LiteralType | FreshableIntrinsicType;
export interface FreshableIntrinsicType extends FreshableType, IntrinsicType {
}
// String literal types (TypeFlags.StringLiteral)
// Numeric literal types (TypeFlags.NumberLiteral)
// BigInt literal types (TypeFlags.BigIntLiteral)
export interface LiteralType extends Type {
export interface LiteralType extends FreshableType {
value: string | number | PseudoBigInt; // Value of literal
freshType: LiteralType; // Fresh version of type
regularType: LiteralType; // Regular version of type
}
// Unique symbol types (TypeFlags.UniqueESSymbol)
@@ -6174,7 +6173,7 @@ export interface BigIntLiteralType extends LiteralType {
}
// Enum types (TypeFlags.Enum)
export interface EnumType extends Type {
export interface EnumType extends FreshableType {
}
// Types included in TypeFlags.ObjectFlagsType have an objectFlags property. Some ObjectFlags
tests/baselines/reference/ambientDeclarations.types
+1 -1
View File
@@ -118,7 +118,7 @@ declare enum E3 {
>E3 : E3
A
>A : E3
>A : E3.A
}
declare module E3 {
>E3 : typeof E3
tests/baselines/reference/ambientEnum1.types
+1 -1
View File
@@ -12,7 +12,7 @@
>E2 : E2
x = 'foo'.length
>x : E2
>x : E2.x
>'foo'.length : number
>'foo' : "foo"
>length : number
tests/baselines/reference/ambientErrors.types
+1 -1
View File
@@ -55,7 +55,7 @@ declare enum E2 {
>E2 : E2
x = 'foo'.length
>x : E2
>x : E2.x
>'foo'.length : number
>'foo' : "foo"
>length : number
tests/baselines/reference/api/tsserverlibrary.d.ts
Vendored
+8 -5
View File
@@ -6675,7 +6675,8 @@ declare namespace ts {
TemplateLiteral = 134217728,
StringMapping = 268435456,
Literal = 2944,
Unit = 109440,
Unit = 109472,
Freshable = 2976,
StringOrNumberLiteral = 384,
PossiblyFalsy = 117724,
StringLike = 402653316,
@@ -6727,10 +6728,12 @@ declare namespace ts {
isClass(): this is InterfaceType;
isIndexType(): this is IndexType;
}
interface LiteralType extends Type {
interface FreshableType extends Type {
freshType: FreshableType;
regularType: FreshableType;
}
interface LiteralType extends FreshableType {
value: string | number | PseudoBigInt;
freshType: LiteralType;
regularType: LiteralType;
}
interface UniqueESSymbolType extends Type {
symbol: Symbol;
@@ -6745,7 +6748,7 @@ declare namespace ts {
interface BigIntLiteralType extends LiteralType {
value: PseudoBigInt;
}
interface EnumType extends Type {
interface EnumType extends FreshableType {
}
enum ObjectFlags {
None = 0,
tests/baselines/reference/api/typescript.d.ts
Vendored
+8 -5
View File
@@ -2700,7 +2700,8 @@ declare namespace ts {
TemplateLiteral = 134217728,
StringMapping = 268435456,
Literal = 2944,
Unit = 109440,
Unit = 109472,
Freshable = 2976,
StringOrNumberLiteral = 384,
PossiblyFalsy = 117724,
StringLike = 402653316,
@@ -2752,10 +2753,12 @@ declare namespace ts {
isClass(): this is InterfaceType;
isIndexType(): this is IndexType;
}
interface LiteralType extends Type {
interface FreshableType extends Type {
freshType: FreshableType;
regularType: FreshableType;
}
interface LiteralType extends FreshableType {
value: string | number | PseudoBigInt;
freshType: LiteralType;
regularType: LiteralType;
}
interface UniqueESSymbolType extends Type {
symbol: Symbol;
@@ -2770,7 +2773,7 @@ declare namespace ts {
interface BigIntLiteralType extends LiteralType {
value: PseudoBigInt;
}
interface EnumType extends Type {
interface EnumType extends FreshableType {
}
enum ObjectFlags {
None = 0,
tests/baselines/reference/computedEnumTypeWidening.js
+192
View File
@@ -0,0 +1,192 @@
//// [computedEnumTypeWidening.ts]
declare function computed(x: number): number;
enum E {
A = computed(0),
B = computed(1),
C = computed(2),
D = computed(3),
}
function f1() {
const c1 = E.B; // Fresh E.B
let v1 = c1; // E
const c2 = c1; // Fresh E.B
let v2 = c2; // E
const c3: E.B = E.B; // E.B
let v3 = c3; // E.B
const c4: E.B = c1; // E.B
let v4 = c4; // E.B
}
function f2(cond: boolean) {
const c1 = cond ? E.A : E.B; // Fresh E.A | fresh E.B
const c2: E.A | E.B = c1; // E.A | E.B
const c3 = cond ? c1 : c2; // E.A | E.B
const c4 = cond ? c3 : E.C; // E.A | E.B | fresh E.C
const c5: E.A | E.B | E.C = c4; // E.A | E.B | E.C
let v1 = c1; // E
let v2 = c2; // E.A | E.B
let v3 = c3; // E.A | E.B
let v4 = c4; // E
let v5 = c5; // E.A | E.B | E.C
}
function f3() {
const c1 = E.B;
let v1 = c1; // E
const c2: E.B = E.B;
let v2 = c2; // E.B
const c3 = E.B as E.B;
let v3 = c3; // E.B
const c4 = <E.B>E.B;
let v4 = c4; // E.B
const c5 = E.B as const;
let v5 = c5; // E.B
}
declare enum E2 { A, B, C, D }
function f4() {
const c1 = E2.B; // Fresh E2.B
let v1 = E.B; // E2
}
const c1 = E.B;
const c2 = E.B as const;
let v1 = E.B;
let v2 = E.B as const;
class C {
p1 = E.B;
p2 = E.B as const;
readonly p3 = E.B;
readonly p4 = E.B as const;
}
// Repro from #52531
enum MyEnum { A, B, C }
let val1 = MyEnum.A;
val1 = MyEnum.B;
declare enum MyDeclaredEnum { A, B, C }
let val2 = MyDeclaredEnum.A;
val2 = MyDeclaredEnum.B;
//// [computedEnumTypeWidening.js]
"use strict";
var E;
(function (E) {
E[E["A"] = computed(0)] = "A";
E[E["B"] = computed(1)] = "B";
E[E["C"] = computed(2)] = "C";
E[E["D"] = computed(3)] = "D";
})(E || (E = {}));
function f1() {
var c1 = E.B; // Fresh E.B
var v1 = c1; // E
var c2 = c1; // Fresh E.B
var v2 = c2; // E
var c3 = E.B; // E.B
var v3 = c3; // E.B
var c4 = c1; // E.B
var v4 = c4; // E.B
}
function f2(cond) {
var c1 = cond ? E.A : E.B; // Fresh E.A | fresh E.B
var c2 = c1; // E.A | E.B
var c3 = cond ? c1 : c2; // E.A | E.B
var c4 = cond ? c3 : E.C; // E.A | E.B | fresh E.C
var c5 = c4; // E.A | E.B | E.C
var v1 = c1; // E
var v2 = c2; // E.A | E.B
var v3 = c3; // E.A | E.B
var v4 = c4; // E
var v5 = c5; // E.A | E.B | E.C
}
function f3() {
var c1 = E.B;
var v1 = c1; // E
var c2 = E.B;
var v2 = c2; // E.B
var c3 = E.B;
var v3 = c3; // E.B
var c4 = E.B;
var v4 = c4; // E.B
var c5 = E.B;
var v5 = c5; // E.B
}
function f4() {
var c1 = E2.B; // Fresh E2.B
var v1 = E.B; // E2
}
var c1 = E.B;
var c2 = E.B;
var v1 = E.B;
var v2 = E.B;
var C = /** @class */ (function () {
function C() {
this.p1 = E.B;
this.p2 = E.B;
this.p3 = E.B;
this.p4 = E.B;
}
return C;
}());
// Repro from #52531
var MyEnum;
(function (MyEnum) {
MyEnum[MyEnum["A"] = 0] = "A";
MyEnum[MyEnum["B"] = 1] = "B";
MyEnum[MyEnum["C"] = 2] = "C";
})(MyEnum || (MyEnum = {}));
var val1 = MyEnum.A;
val1 = MyEnum.B;
var val2 = MyDeclaredEnum.A;
val2 = MyDeclaredEnum.B;
//// [computedEnumTypeWidening.d.ts]
declare function computed(x: number): number;
declare enum E {
A,
B,
C,
D
}
declare function f1(): void;
declare function f2(cond: boolean): void;
declare function f3(): void;
declare enum E2 {
A,
B,
C,
D
}
declare function f4(): void;
declare const c1 = E.B;
declare const c2: E.B;
declare let v1: E;
declare let v2: E.B;
declare class C {
p1: E;
p2: E.B;
readonly p3 = E.B;
readonly p4: E.B;
}
declare enum MyEnum {
A = 0,
B = 1,
C = 2
}
declare let val1: MyEnum;
declare enum MyDeclaredEnum {
A,
B,
C
}
declare let val2: MyDeclaredEnum;
tests/baselines/reference/computedEnumTypeWidening.symbols
+314
View File
@@ -0,0 +1,314 @@
=== tests/cases/compiler/computedEnumTypeWidening.ts ===
declare function computed(x: number): number;
>computed : Symbol(computed, Decl(computedEnumTypeWidening.ts, 0, 0))
>x : Symbol(x, Decl(computedEnumTypeWidening.ts, 0, 26))
enum E {
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
A = computed(0),
>A : Symbol(E.A, Decl(computedEnumTypeWidening.ts, 2, 8))
>computed : Symbol(computed, Decl(computedEnumTypeWidening.ts, 0, 0))
B = computed(1),
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>computed : Symbol(computed, Decl(computedEnumTypeWidening.ts, 0, 0))
C = computed(2),
>C : Symbol(E.C, Decl(computedEnumTypeWidening.ts, 4, 20))
>computed : Symbol(computed, Decl(computedEnumTypeWidening.ts, 0, 0))
D = computed(3),
>D : Symbol(E.D, Decl(computedEnumTypeWidening.ts, 5, 20))
>computed : Symbol(computed, Decl(computedEnumTypeWidening.ts, 0, 0))
}
function f1() {
>f1 : Symbol(f1, Decl(computedEnumTypeWidening.ts, 7, 1))
const c1 = E.B; // Fresh E.B
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 10, 9))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v1 = c1; // E
>v1 : Symbol(v1, Decl(computedEnumTypeWidening.ts, 11, 7))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 10, 9))
const c2 = c1; // Fresh E.B
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 12, 9))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 10, 9))
let v2 = c2; // E
>v2 : Symbol(v2, Decl(computedEnumTypeWidening.ts, 13, 7))
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 12, 9))
const c3: E.B = E.B; // E.B
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 14, 9))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v3 = c3; // E.B
>v3 : Symbol(v3, Decl(computedEnumTypeWidening.ts, 15, 7))
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 14, 9))
const c4: E.B = c1; // E.B
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 16, 9))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 10, 9))
let v4 = c4; // E.B
>v4 : Symbol(v4, Decl(computedEnumTypeWidening.ts, 17, 7))
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 16, 9))
}
function f2(cond: boolean) {
>f2 : Symbol(f2, Decl(computedEnumTypeWidening.ts, 18, 1))
>cond : Symbol(cond, Decl(computedEnumTypeWidening.ts, 20, 12))
const c1 = cond ? E.A : E.B; // Fresh E.A | fresh E.B
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 21, 9))
>cond : Symbol(cond, Decl(computedEnumTypeWidening.ts, 20, 12))
>E.A : Symbol(E.A, Decl(computedEnumTypeWidening.ts, 2, 8))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>A : Symbol(E.A, Decl(computedEnumTypeWidening.ts, 2, 8))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
const c2: E.A | E.B = c1; // E.A | E.B
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 22, 9))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>A : Symbol(E.A, Decl(computedEnumTypeWidening.ts, 2, 8))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 21, 9))
const c3 = cond ? c1 : c2; // E.A | E.B
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 23, 9))
>cond : Symbol(cond, Decl(computedEnumTypeWidening.ts, 20, 12))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 21, 9))
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 22, 9))
const c4 = cond ? c3 : E.C; // E.A | E.B | fresh E.C
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 24, 9))
>cond : Symbol(cond, Decl(computedEnumTypeWidening.ts, 20, 12))
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 23, 9))
>E.C : Symbol(E.C, Decl(computedEnumTypeWidening.ts, 4, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>C : Symbol(E.C, Decl(computedEnumTypeWidening.ts, 4, 20))
const c5: E.A | E.B | E.C = c4; // E.A | E.B | E.C
>c5 : Symbol(c5, Decl(computedEnumTypeWidening.ts, 25, 9))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>A : Symbol(E.A, Decl(computedEnumTypeWidening.ts, 2, 8))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>C : Symbol(E.C, Decl(computedEnumTypeWidening.ts, 4, 20))
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 24, 9))
let v1 = c1; // E
>v1 : Symbol(v1, Decl(computedEnumTypeWidening.ts, 26, 7))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 21, 9))
let v2 = c2; // E.A | E.B
>v2 : Symbol(v2, Decl(computedEnumTypeWidening.ts, 27, 7))
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 22, 9))
let v3 = c3; // E.A | E.B
>v3 : Symbol(v3, Decl(computedEnumTypeWidening.ts, 28, 7))
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 23, 9))
let v4 = c4; // E
>v4 : Symbol(v4, Decl(computedEnumTypeWidening.ts, 29, 7))
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 24, 9))
let v5 = c5; // E.A | E.B | E.C
>v5 : Symbol(v5, Decl(computedEnumTypeWidening.ts, 30, 7))
>c5 : Symbol(c5, Decl(computedEnumTypeWidening.ts, 25, 9))
}
function f3() {
>f3 : Symbol(f3, Decl(computedEnumTypeWidening.ts, 31, 1))
const c1 = E.B;
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 34, 9))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v1 = c1; // E
>v1 : Symbol(v1, Decl(computedEnumTypeWidening.ts, 35, 7))
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 34, 9))
const c2: E.B = E.B;
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 36, 9))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v2 = c2; // E.B
>v2 : Symbol(v2, Decl(computedEnumTypeWidening.ts, 37, 7))
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 36, 9))
const c3 = E.B as E.B;
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 38, 9))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v3 = c3; // E.B
>v3 : Symbol(v3, Decl(computedEnumTypeWidening.ts, 39, 7))
>c3 : Symbol(c3, Decl(computedEnumTypeWidening.ts, 38, 9))
const c4 = <E.B>E.B;
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 40, 9))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v4 = c4; // E.B
>v4 : Symbol(v4, Decl(computedEnumTypeWidening.ts, 41, 7))
>c4 : Symbol(c4, Decl(computedEnumTypeWidening.ts, 40, 9))
const c5 = E.B as const;
>c5 : Symbol(c5, Decl(computedEnumTypeWidening.ts, 42, 9))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>const : Symbol(const)
let v5 = c5; // E.B
>v5 : Symbol(v5, Decl(computedEnumTypeWidening.ts, 43, 7))
>c5 : Symbol(c5, Decl(computedEnumTypeWidening.ts, 42, 9))
}
declare enum E2 { A, B, C, D }
>E2 : Symbol(E2, Decl(computedEnumTypeWidening.ts, 44, 1))
>A : Symbol(E2.A, Decl(computedEnumTypeWidening.ts, 46, 17))
>B : Symbol(E2.B, Decl(computedEnumTypeWidening.ts, 46, 20))
>C : Symbol(E2.C, Decl(computedEnumTypeWidening.ts, 46, 23))
>D : Symbol(E2.D, Decl(computedEnumTypeWidening.ts, 46, 26))
function f4() {
>f4 : Symbol(f4, Decl(computedEnumTypeWidening.ts, 46, 30))
const c1 = E2.B; // Fresh E2.B
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 49, 9))
>E2.B : Symbol(E2.B, Decl(computedEnumTypeWidening.ts, 46, 20))
>E2 : Symbol(E2, Decl(computedEnumTypeWidening.ts, 44, 1))
>B : Symbol(E2.B, Decl(computedEnumTypeWidening.ts, 46, 20))
let v1 = E.B; // E2
>v1 : Symbol(v1, Decl(computedEnumTypeWidening.ts, 50, 7))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
}
const c1 = E.B;
>c1 : Symbol(c1, Decl(computedEnumTypeWidening.ts, 53, 5))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
const c2 = E.B as const;
>c2 : Symbol(c2, Decl(computedEnumTypeWidening.ts, 54, 5))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>const : Symbol(const)
let v1 = E.B;
>v1 : Symbol(v1, Decl(computedEnumTypeWidening.ts, 55, 3))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
let v2 = E.B as const;
>v2 : Symbol(v2, Decl(computedEnumTypeWidening.ts, 56, 3))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>const : Symbol(const)
class C {
>C : Symbol(C, Decl(computedEnumTypeWidening.ts, 56, 22))
p1 = E.B;
>p1 : Symbol(C.p1, Decl(computedEnumTypeWidening.ts, 58, 9))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
p2 = E.B as const;
>p2 : Symbol(C.p2, Decl(computedEnumTypeWidening.ts, 59, 11))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>const : Symbol(const)
readonly p3 = E.B;
>p3 : Symbol(C.p3, Decl(computedEnumTypeWidening.ts, 60, 20))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
readonly p4 = E.B as const;
>p4 : Symbol(C.p4, Decl(computedEnumTypeWidening.ts, 61, 20))
>E.B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>E : Symbol(E, Decl(computedEnumTypeWidening.ts, 0, 45))
>B : Symbol(E.B, Decl(computedEnumTypeWidening.ts, 3, 20))
>const : Symbol(const)
}
// Repro from #52531
enum MyEnum { A, B, C }
>MyEnum : Symbol(MyEnum, Decl(computedEnumTypeWidening.ts, 63, 1))
>A : Symbol(MyEnum.A, Decl(computedEnumTypeWidening.ts, 67, 13))
>B : Symbol(MyEnum.B, Decl(computedEnumTypeWidening.ts, 67, 16))
>C : Symbol(MyEnum.C, Decl(computedEnumTypeWidening.ts, 67, 19))
let val1 = MyEnum.A;
>val1 : Symbol(val1, Decl(computedEnumTypeWidening.ts, 69, 3))
>MyEnum.A : Symbol(MyEnum.A, Decl(computedEnumTypeWidening.ts, 67, 13))
>MyEnum : Symbol(MyEnum, Decl(computedEnumTypeWidening.ts, 63, 1))
>A : Symbol(MyEnum.A, Decl(computedEnumTypeWidening.ts, 67, 13))
val1 = MyEnum.B;
>val1 : Symbol(val1, Decl(computedEnumTypeWidening.ts, 69, 3))
>MyEnum.B : Symbol(MyEnum.B, Decl(computedEnumTypeWidening.ts, 67, 16))
>MyEnum : Symbol(MyEnum, Decl(computedEnumTypeWidening.ts, 63, 1))
>B : Symbol(MyEnum.B, Decl(computedEnumTypeWidening.ts, 67, 16))
declare enum MyDeclaredEnum { A, B, C }
>MyDeclaredEnum : Symbol(MyDeclaredEnum, Decl(computedEnumTypeWidening.ts, 70, 16))
>A : Symbol(MyDeclaredEnum.A, Decl(computedEnumTypeWidening.ts, 72, 29))
>B : Symbol(MyDeclaredEnum.B, Decl(computedEnumTypeWidening.ts, 72, 32))
>C : Symbol(MyDeclaredEnum.C, Decl(computedEnumTypeWidening.ts, 72, 35))
let val2 = MyDeclaredEnum.A;
>val2 : Symbol(val2, Decl(computedEnumTypeWidening.ts, 74, 3))
>MyDeclaredEnum.A : Symbol(MyDeclaredEnum.A, Decl(computedEnumTypeWidening.ts, 72, 29))
>MyDeclaredEnum : Symbol(MyDeclaredEnum, Decl(computedEnumTypeWidening.ts, 70, 16))
>A : Symbol(MyDeclaredEnum.A, Decl(computedEnumTypeWidening.ts, 72, 29))
val2 = MyDeclaredEnum.B;
>val2 : Symbol(val2, Decl(computedEnumTypeWidening.ts, 74, 3))
>MyDeclaredEnum.B : Symbol(MyDeclaredEnum.B, Decl(computedEnumTypeWidening.ts, 72, 32))
>MyDeclaredEnum : Symbol(MyDeclaredEnum, Decl(computedEnumTypeWidening.ts, 70, 16))
>B : Symbol(MyDeclaredEnum.B, Decl(computedEnumTypeWidening.ts, 72, 32))
tests/baselines/reference/computedEnumTypeWidening.types
+319
View File
@@ -0,0 +1,319 @@
=== tests/cases/compiler/computedEnumTypeWidening.ts ===
declare function computed(x: number): number;
>computed : (x: number) => number
>x : number
enum E {
>E : E
A = computed(0),
>A : E.A
>computed(0) : number
>computed : (x: number) => number
>0 : 0
B = computed(1),
>B : E.B
>computed(1) : number
>computed : (x: number) => number
>1 : 1
C = computed(2),
>C : E.C
>computed(2) : number
>computed : (x: number) => number
>2 : 2
D = computed(3),
>D : E.D
>computed(3) : number
>computed : (x: number) => number
>3 : 3
}
function f1() {
>f1 : () => void
const c1 = E.B; // Fresh E.B
>c1 : E.B
>E.B : E.B
>E : typeof E
>B : E.B
let v1 = c1; // E
>v1 : E
>c1 : E.B
const c2 = c1; // Fresh E.B
>c2 : E.B
>c1 : E.B
let v2 = c2; // E
>v2 : E
>c2 : E.B
const c3: E.B = E.B; // E.B
>c3 : E.B
>E : any
>E.B : E.B
>E : typeof E
>B : E.B
let v3 = c3; // E.B
>v3 : E.B
>c3 : E.B
const c4: E.B = c1; // E.B
>c4 : E.B
>E : any
>c1 : E.B
let v4 = c4; // E.B
>v4 : E.B
>c4 : E.B
}
function f2(cond: boolean) {
>f2 : (cond: boolean) => void
>cond : boolean
const c1 = cond ? E.A : E.B; // Fresh E.A | fresh E.B
>c1 : E.A | E.B
>cond ? E.A : E.B : E.A | E.B
>cond : boolean
>E.A : E.A
>E : typeof E
>A : E.A
>E.B : E.B
>E : typeof E
>B : E.B
const c2: E.A | E.B = c1; // E.A | E.B
>c2 : E.A | E.B
>E : any
>E : any
>c1 : E.A | E.B
const c3 = cond ? c1 : c2; // E.A | E.B
>c3 : E.A | E.B
>cond ? c1 : c2 : E.A | E.B
>cond : boolean
>c1 : E.A | E.B
>c2 : E.A | E.B
const c4 = cond ? c3 : E.C; // E.A | E.B | fresh E.C
>c4 : E.A | E.B | E.C
>cond ? c3 : E.C : E.A | E.B | E.C
>cond : boolean
>c3 : E.A | E.B
>E.C : E.C
>E : typeof E
>C : E.C
const c5: E.A | E.B | E.C = c4; // E.A | E.B | E.C
>c5 : E.A | E.B | E.C
>E : any
>E : any
>E : any
>c4 : E.A | E.B | E.C
let v1 = c1; // E
>v1 : E
>c1 : E.A | E.B
let v2 = c2; // E.A | E.B
>v2 : E.A | E.B
>c2 : E.A | E.B
let v3 = c3; // E.A | E.B
>v3 : E.A | E.B
>c3 : E.A | E.B
let v4 = c4; // E
>v4 : E
>c4 : E.A | E.B | E.C
let v5 = c5; // E.A | E.B | E.C
>v5 : E.A | E.B | E.C
>c5 : E.A | E.B | E.C
}
function f3() {
>f3 : () => void
const c1 = E.B;
>c1 : E.B
>E.B : E.B
>E : typeof E
>B : E.B
let v1 = c1; // E
>v1 : E
>c1 : E.B
const c2: E.B = E.B;
>c2 : E.B
>E : any
>E.B : E.B
>E : typeof E
>B : E.B
let v2 = c2; // E.B
>v2 : E.B
>c2 : E.B
const c3 = E.B as E.B;
>c3 : E.B
>E.B as E.B : E.B
>E.B : E.B
>E : typeof E
>B : E.B
>E : any
let v3 = c3; // E.B
>v3 : E.B
>c3 : E.B
const c4 = <E.B>E.B;
>c4 : E.B
><E.B>E.B : E.B
>E : any
>E.B : E.B
>E : typeof E
>B : E.B
let v4 = c4; // E.B
>v4 : E.B
>c4 : E.B
const c5 = E.B as const;
>c5 : E.B
>E.B as const : E.B
>E.B : E.B
>E : typeof E
>B : E.B
let v5 = c5; // E.B
>v5 : E.B
>c5 : E.B
}
declare enum E2 { A, B, C, D }
>E2 : E2
>A : E2.A
>B : E2.B
>C : E2.C
>D : E2.D
function f4() {
>f4 : () => void
const c1 = E2.B; // Fresh E2.B
>c1 : E2.B
>E2.B : E2.B
>E2 : typeof E2
>B : E2.B
let v1 = E.B; // E2
>v1 : E
>E.B : E.B
>E : typeof E
>B : E.B
}
const c1 = E.B;
>c1 : E.B
>E.B : E.B
>E : typeof E
>B : E.B
const c2 = E.B as const;
>c2 : E.B
>E.B as const : E.B
>E.B : E.B
>E : typeof E
>B : E.B
let v1 = E.B;
>v1 : E
>E.B : E.B
>E : typeof E
>B : E.B
let v2 = E.B as const;
>v2 : E.B
>E.B as const : E.B
>E.B : E.B
>E : typeof E
>B : E.B
class C {
>C : C
p1 = E.B;
>p1 : E
>E.B : E.B
>E : typeof E
>B : E.B
p2 = E.B as const;
>p2 : E.B
>E.B as const : E.B
>E.B : E.B
>E : typeof E
>B : E.B
readonly p3 = E.B;
>p3 : E.B
>E.B : E.B
>E : typeof E
>B : E.B
readonly p4 = E.B as const;
>p4 : E.B
>E.B as const : E.B
>E.B : E.B
>E : typeof E
>B : E.B
}
// Repro from #52531
enum MyEnum { A, B, C }
>MyEnum : MyEnum
>A : MyEnum.A
>B : MyEnum.B
>C : MyEnum.C
let val1 = MyEnum.A;
>val1 : MyEnum
>MyEnum.A : MyEnum.A
>MyEnum : typeof MyEnum
>A : MyEnum.A
val1 = MyEnum.B;
>val1 = MyEnum.B : MyEnum.B
>val1 : MyEnum
>MyEnum.B : MyEnum.B
>MyEnum : typeof MyEnum
>B : MyEnum.B
declare enum MyDeclaredEnum { A, B, C }
>MyDeclaredEnum : MyDeclaredEnum
>A : MyDeclaredEnum.A
>B : MyDeclaredEnum.B
>C : MyDeclaredEnum.C
let val2 = MyDeclaredEnum.A;
>val2 : MyDeclaredEnum
>MyDeclaredEnum.A : MyDeclaredEnum.A
>MyDeclaredEnum : typeof MyDeclaredEnum
>A : MyDeclaredEnum.A
val2 = MyDeclaredEnum.B;
>val2 = MyDeclaredEnum.B : MyDeclaredEnum.B
>val2 : MyDeclaredEnum
>MyDeclaredEnum.B : MyDeclaredEnum.B
>MyDeclaredEnum : typeof MyDeclaredEnum
>B : MyDeclaredEnum.B
tests/baselines/reference/declarationEmitForGlobalishSpecifierSymlink.types
+2 -2
View File
@@ -6,7 +6,7 @@ export enum A {
>A : A
Val
>Val : A
>Val : A.Val
}
=== /p1/node_modules/typescript-fsa/index.d.ts ===
@@ -19,7 +19,7 @@ export enum A {
>A : A
Val
>Val : A
>Val : A.Val
}
=== /p2/node_modules/typescript-fsa/index.d.ts ===
tests/baselines/reference/declarationEmitForGlobalishSpecifierSymlink2.types
+1 -1
View File
@@ -6,7 +6,7 @@ export enum A {
>A : A
Val
>Val : A
>Val : A.Val
}
=== /cache/typescript-fsa/index.d.ts ===
tests/baselines/reference/disallowLineTerminatorBeforeArrow.types
+1 -1
View File
@@ -194,7 +194,7 @@ module m {
>Enum : Enum
claw = (()
>claw : Enum
>claw : Enum.claw
>(() => 10)() : number
>(() => 10) : () => number
>() => 10 : () => number
tests/baselines/reference/enumBasics.types
+4 -4
View File
@@ -140,7 +140,7 @@ enum E7 {
>E7 : E7
A = 'foo'['foo']
>A : E7
>A : E7.A
>'foo'['foo'] : error
>'foo' : "foo"
>'foo' : "foo"
@@ -151,7 +151,7 @@ enum E8 {
>E8 : E8
B = 'foo'['foo']
>B : E8
>B : E8.B
>'foo'['foo'] : error
>'foo' : "foo"
>'foo' : "foo"
@@ -172,8 +172,8 @@ enum E9 {
// (refer to .js to validate)
// Enum constant members are propagated
var doNotPropagate = [
>doNotPropagate : (E8 | E7 | E4.Z | E3)[]
>[ E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z] : (E8 | E7 | E4.Z | E3)[]
>doNotPropagate : (E8 | E7 | E4 | E3)[]
>[ E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z] : (E8 | E7 | E4 | E3)[]
E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z
>E8.B : E8
tests/baselines/reference/enumErrors.types
+1 -1
View File
@@ -17,7 +17,7 @@ enum E5 {
>E5 : E5
C = new Number(30)
>C : E5
>C : E5.C
>new Number(30) : Number
>Number : NumberConstructor
>30 : 30
tests/baselines/reference/enumMerging.types
+2 -2
View File
@@ -111,8 +111,8 @@ module M2 {
}
var x = [EComp2.A, EComp2.B, EComp2.C, EComp2.D, EComp2.E, EComp2.F];
>x : (EComp2.A | EComp2.B | EComp2.C | EComp2.D | EComp2.E | EComp2.F)[]
>[EComp2.A, EComp2.B, EComp2.C, EComp2.D, EComp2.E, EComp2.F] : (EComp2.A | EComp2.B | EComp2.C | EComp2.D | EComp2.E | EComp2.F)[]
>x : EComp2[]
>[EComp2.A, EComp2.B, EComp2.C, EComp2.D, EComp2.E, EComp2.F] : EComp2[]
>EComp2.A : EComp2.A
>EComp2 : typeof EComp2
>A : EComp2.A
tests/baselines/reference/enumWithExport.types
+1 -1
View File
@@ -10,6 +10,6 @@ enum x {
>x : x
z = y
>z : x
>z : x.z
>y : any
}
tests/baselines/reference/methodContainingLocalFunction.types
+1 -1
View File
@@ -105,7 +105,7 @@ enum E {
>E : E
A = (() => {
>A : E
>A : E.A
>(() => { function localFunction() { } var x: { (): void; }; x = localFunction; return 0; })() : number
>(() => { function localFunction() { } var x: { (): void; }; x = localFunction; return 0; }) : () => number
>() => { function localFunction() { } var x: { (): void; }; x = localFunction; return 0; } : () => number
tests/baselines/reference/moduleLocalImportNotIncorrectlyRedirected.types
+1 -1
View File
@@ -15,5 +15,5 @@ export declare enum Position {
>Position : Position
top,
>top : Position
>top : Position.top
}
tests/baselines/reference/numericEnumMappedType.types
+1 -1
View File
@@ -91,7 +91,7 @@ enum N2 { C = val(), D = val() }
>val : () => number
type T1 = { [K in N1 | N2]: K };
>T1 : { [x: number]: N1.A | N1.B | N2.C | N2.D; }
>T1 : { [x: number]: N1 | N2; }
// Enum types with string valued members are always literal enum types and therefore
// ONE and TWO below are not computed members but rather just numerically valued members
tests/baselines/reference/this_inside-enum-should-not-be-allowed.types
+2 -2
View File
@@ -3,7 +3,7 @@ enum TopLevelEnum {
>TopLevelEnum : TopLevelEnum
ThisWasAllowedButShouldNotBe = this // Should not be allowed
>ThisWasAllowedButShouldNotBe : TopLevelEnum
>ThisWasAllowedButShouldNotBe : TopLevelEnum.ThisWasAllowedButShouldNotBe
>this : any
}
@@ -14,7 +14,7 @@ module ModuleEnum {
>EnumInModule : EnumInModule
WasADifferentError = this // this was handled as if this was in a module
>WasADifferentError : EnumInModule
>WasADifferentError : EnumInModule.WasADifferentError
>this : any
}
}
tests/cases/compiler/computedEnumTypeWidening.ts
+79
View File
@@ -0,0 +1,79 @@
// @strict: true
// @declaration: true
declare function computed(x: number): number;
enum E {
A = computed(0),
B = computed(1),
C = computed(2),
D = computed(3),
}
function f1() {
const c1 = E.B; // Fresh E.B
let v1 = c1; // E
const c2 = c1; // Fresh E.B
let v2 = c2; // E
const c3: E.B = E.B; // E.B
let v3 = c3; // E.B
const c4: E.B = c1; // E.B
let v4 = c4; // E.B
}
function f2(cond: boolean) {
const c1 = cond ? E.A : E.B; // Fresh E.A | fresh E.B
const c2: E.A | E.B = c1; // E.A | E.B
const c3 = cond ? c1 : c2; // E.A | E.B
const c4 = cond ? c3 : E.C; // E.A | E.B | fresh E.C
const c5: E.A | E.B | E.C = c4; // E.A | E.B | E.C
let v1 = c1; // E
let v2 = c2; // E.A | E.B
let v3 = c3; // E.A | E.B
let v4 = c4; // E
let v5 = c5; // E.A | E.B | E.C
}
function f3() {
const c1 = E.B;
let v1 = c1; // E
const c2: E.B = E.B;
let v2 = c2; // E.B
const c3 = E.B as E.B;
let v3 = c3; // E.B
const c4 = <E.B>E.B;
let v4 = c4; // E.B
const c5 = E.B as const;
let v5 = c5; // E.B
}
declare enum E2 { A, B, C, D }
function f4() {
const c1 = E2.B; // Fresh E2.B
let v1 = E.B; // E2
}
const c1 = E.B;
const c2 = E.B as const;
let v1 = E.B;
let v2 = E.B as const;
class C {
p1 = E.B;
p2 = E.B as const;
readonly p3 = E.B;
readonly p4 = E.B as const;
}
// Repro from #52531
enum MyEnum { A, B, C }
let val1 = MyEnum.A;
val1 = MyEnum.B;
declare enum MyDeclaredEnum { A, B, C }
let val2 = MyDeclaredEnum.A;
val2 = MyDeclaredEnum.B;