From 93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 20 Dec 2023 13:52:11 -0800 Subject: [PATCH] Enforce identical enum values in compatibility checks (#55924) --- src/compiler/checker.ts | 48 +++- src/compiler/diagnosticMessages.json | 8 + src/compiler/types.ts | 1 + .../enumAssignmentCompat3.errors.txt | 31 ++- .../reference/enumAssignmentCompat3.js | 12 +- .../reference/enumAssignmentCompat3.symbols | 6 +- .../reference/enumAssignmentCompat3.types | 6 +- .../enumAssignmentCompat6.errors.txt | 115 ++++++++++ .../reference/enumAssignmentCompat6.js | 148 ++++++++++++ .../reference/enumAssignmentCompat6.symbols | 202 +++++++++++++++++ .../reference/enumAssignmentCompat6.types | 214 ++++++++++++++++++ .../enumAssignmentCompat7.errors.txt | 42 ++++ .../reference/enumAssignmentCompat7.js | 77 +++++++ .../reference/enumAssignmentCompat7.symbols | 58 +++++ .../reference/enumAssignmentCompat7.types | 58 +++++ tests/cases/compiler/enumAssignmentCompat3.ts | 6 +- tests/cases/compiler/enumAssignmentCompat6.ts | 77 +++++++ tests/cases/compiler/enumAssignmentCompat7.ts | 26 +++ 18 files changed, 1108 insertions(+), 27 deletions(-) create mode 100644 tests/baselines/reference/enumAssignmentCompat6.errors.txt create mode 100644 tests/baselines/reference/enumAssignmentCompat6.js create mode 100644 tests/baselines/reference/enumAssignmentCompat6.symbols create mode 100644 tests/baselines/reference/enumAssignmentCompat6.types create mode 100644 tests/baselines/reference/enumAssignmentCompat7.errors.txt create mode 100644 tests/baselines/reference/enumAssignmentCompat7.js create mode 100644 tests/baselines/reference/enumAssignmentCompat7.symbols create mode 100644 tests/baselines/reference/enumAssignmentCompat7.types create mode 100644 tests/cases/compiler/enumAssignmentCompat6.ts create mode 100644 tests/cases/compiler/enumAssignmentCompat7.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 43cff3cb52388..ceb99b65eefab 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -20883,12 +20883,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return !!(entry & RelationComparisonResult.Succeeded); } const targetEnumType = getTypeOfSymbol(targetSymbol); - for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) { - if (property.flags & SymbolFlags.EnumMember) { - const targetProperty = getPropertyOfType(targetEnumType, property.escapedName); + for (const sourceProperty of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) { + if (sourceProperty.flags & SymbolFlags.EnumMember) { + const targetProperty = getPropertyOfType(targetEnumType, sourceProperty.escapedName); if (!targetProperty || !(targetProperty.flags & SymbolFlags.EnumMember)) { if (errorReporter) { - errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property), typeToString(getDeclaredTypeOfSymbol(targetSymbol), /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType)); + errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(sourceProperty), typeToString(getDeclaredTypeOfSymbol(targetSymbol), /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType)); enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported); } else { @@ -20896,6 +20896,46 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } return false; } + const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, SyntaxKind.EnumMember)!); + const targetValue = getEnumMemberValue(getDeclarationOfKind(targetProperty, SyntaxKind.EnumMember)!); + if (sourceValue !== targetValue) { + const sourceIsString = typeof sourceValue === "string"; + const targetIsString = typeof targetValue === "string"; + + // If we have 2 enums with *known* values that differ, they are incompatible. + if (sourceValue !== undefined && targetValue !== undefined) { + if (!errorReporter) { + enumRelation.set(id, RelationComparisonResult.Failed); + } + else { + const escapedSource = sourceIsString ? `"${escapeString(sourceValue)}"` : sourceValue; + const escapedTarget = targetIsString ? `"${escapeString(targetValue)}"` : targetValue; + errorReporter(Diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given, symbolName(targetSymbol), symbolName(targetProperty), escapedTarget, escapedSource); + enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported); + } + return false; + } + + // At this point we know that at least one of the values is 'undefined'. + // This may mean that we have an opaque member from an ambient enum declaration, + // or that we were not able to calculate it (which is basically an error). + // + // Either way, we can assume that it's numeric. + // If the other is a string, we have a mismatch in types. + if (sourceIsString || targetIsString) { + if (!errorReporter) { + enumRelation.set(id, RelationComparisonResult.Failed); + } + else { + const knownStringValue = sourceValue ?? targetValue; + Debug.assert(typeof knownStringValue === "string"); + const escapedValue = `"${escapeString(knownStringValue)}"`; + errorReporter(Diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value, symbolName(targetSymbol), symbolName(targetProperty), escapedValue); + enumRelation.set(id, RelationComparisonResult.Failed | RelationComparisonResult.Reported); + } + return false; + } + } } } enumRelation.set(id, RelationComparisonResult.Succeeded); diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 5a71fa894b107..1979557243abb 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -4176,6 +4176,14 @@ "category": "Error", "code": 4124 }, + "Each declaration of '{0}.{1}' differs in its value, where '{2}' was expected but '{3}' was given.": { + "category": "Error", + "code": 4125 + }, + "One value of '{0}.{1}' is the string '{2}', and the other is assumed to be an unknown numeric value.": { + "category": "Error", + "code": 4126 + }, "The current host does not support the '{0}' option.": { "category": "Error", diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 6b7548280c60f..b8aab9a8563c4 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -916,6 +916,7 @@ export const enum JsxFlags { // dprint-ignore /** @internal */ export const enum RelationComparisonResult { + None = 0, Succeeded = 1 << 0, // Should be truthy Failed = 1 << 1, Reported = 1 << 2, diff --git a/tests/baselines/reference/enumAssignmentCompat3.errors.txt b/tests/baselines/reference/enumAssignmentCompat3.errors.txt index efe726d5ddae1..9c10fd6b13d95 100644 --- a/tests/baselines/reference/enumAssignmentCompat3.errors.txt +++ b/tests/baselines/reference/enumAssignmentCompat3.errors.txt @@ -1,20 +1,26 @@ enumAssignmentCompat3.ts(68,1): error TS2322: Type 'Abcd.E' is not assignable to type 'First.E'. Property 'd' is missing in type 'First.E'. enumAssignmentCompat3.ts(70,1): error TS2322: Type 'Cd.E' is not assignable to type 'First.E'. - Property 'd' is missing in type 'First.E'. + Each declaration of 'E.c' differs in its value, where '2' was expected but '0' was given. enumAssignmentCompat3.ts(71,1): error TS2322: Type 'Nope' is not assignable to type 'E'. +enumAssignmentCompat3.ts(72,1): error TS2322: Type 'Decl.E' is not assignable to type 'First.E'. + Each declaration of 'E.c' differs in its value, where '2' was expected but '3' was given. enumAssignmentCompat3.ts(75,1): error TS2322: Type 'First.E' is not assignable to type 'Ab.E'. Property 'c' is missing in type 'Ab.E'. enumAssignmentCompat3.ts(76,1): error TS2322: Type 'First.E' is not assignable to type 'Cd.E'. Property 'a' is missing in type 'Cd.E'. enumAssignmentCompat3.ts(77,1): error TS2322: Type 'E' is not assignable to type 'Nope'. +enumAssignmentCompat3.ts(78,1): error TS2322: Type 'First.E' is not assignable to type 'Decl.E'. + Each declaration of 'E.c' differs in its value, where '3' was expected but '2' was given. enumAssignmentCompat3.ts(82,1): error TS2322: Type 'Const.E' is not assignable to type 'First.E'. enumAssignmentCompat3.ts(83,1): error TS2322: Type 'First.E' is not assignable to type 'Const.E'. enumAssignmentCompat3.ts(86,1): error TS2322: Type 'Merged.E' is not assignable to type 'First.E'. - Property 'd' is missing in type 'First.E'. + Each declaration of 'E.c' differs in its value, where '2' was expected but '3' was given. +enumAssignmentCompat3.ts(87,1): error TS2322: Type 'First.E' is not assignable to type 'Merged.E'. + Each declaration of 'E.c' differs in its value, where '3' was expected but '2' was given. -==== enumAssignmentCompat3.ts (9 errors) ==== +==== enumAssignmentCompat3.ts (12 errors) ==== namespace First { export enum E { a, b, c, @@ -90,11 +96,14 @@ enumAssignmentCompat3.ts(86,1): error TS2322: Type 'Merged.E' is not assignable abc = secondCd; // missing 'd' ~~~ !!! error TS2322: Type 'Cd.E' is not assignable to type 'First.E'. -!!! error TS2322: Property 'd' is missing in type 'First.E'. +!!! error TS2322: Each declaration of 'E.c' differs in its value, where '2' was expected but '0' was given. abc = nope; // nope! ~~~ !!! error TS2322: Type 'Nope' is not assignable to type 'E'. - abc = decl; // ok + abc = decl; // bad - value of 'c' differs between these enums + ~~~ +!!! error TS2322: Type 'Decl.E' is not assignable to type 'First.E'. +!!! error TS2322: Each declaration of 'E.c' differs in its value, where '2' was expected but '3' was given. secondAbc = abc; // ok secondAbcd = abc; // ok secondAb = abc; // missing 'c' @@ -108,7 +117,10 @@ enumAssignmentCompat3.ts(86,1): error TS2322: Type 'Merged.E' is not assignable nope = abc; // nope! ~~~~ !!! error TS2322: Type 'E' is not assignable to type 'Nope'. - decl = abc; // ok + decl = abc; // bad - value of 'c' differs between these enums + ~~~~ +!!! error TS2322: Type 'First.E' is not assignable to type 'Decl.E'. +!!! error TS2322: Each declaration of 'E.c' differs in its value, where '3' was expected but '2' was given. // const is only assignable to itself k = k; @@ -123,7 +135,10 @@ enumAssignmentCompat3.ts(86,1): error TS2322: Type 'Merged.E' is not assignable abc = merged; // missing 'd' ~~~ !!! error TS2322: Type 'Merged.E' is not assignable to type 'First.E'. -!!! error TS2322: Property 'd' is missing in type 'First.E'. - merged = abc; // ok +!!! error TS2322: Each declaration of 'E.c' differs in its value, where '2' was expected but '3' was given. + merged = abc; // bad - value of 'c' differs between these enums + ~~~~~~ +!!! error TS2322: Type 'First.E' is not assignable to type 'Merged.E'. +!!! error TS2322: Each declaration of 'E.c' differs in its value, where '3' was expected but '2' was given. abc = merged2; // ok merged2 = abc; // ok \ No newline at end of file diff --git a/tests/baselines/reference/enumAssignmentCompat3.js b/tests/baselines/reference/enumAssignmentCompat3.js index ac83fb96c317a..755ddb169cfec 100644 --- a/tests/baselines/reference/enumAssignmentCompat3.js +++ b/tests/baselines/reference/enumAssignmentCompat3.js @@ -72,13 +72,13 @@ abc = secondAbcd; // missing 'd' abc = secondAb; // ok abc = secondCd; // missing 'd' abc = nope; // nope! -abc = decl; // ok +abc = decl; // bad - value of 'c' differs between these enums secondAbc = abc; // ok secondAbcd = abc; // ok secondAb = abc; // missing 'c' secondCd = abc; // missing 'a' and 'b' nope = abc; // nope! -decl = abc; // ok +decl = abc; // bad - value of 'c' differs between these enums // const is only assignable to itself k = k; @@ -87,7 +87,7 @@ k = abc; // merged enums compare all their members abc = merged; // missing 'd' -merged = abc; // ok +merged = abc; // bad - value of 'c' differs between these enums abc = merged2; // ok merged2 = abc; // ok @@ -184,19 +184,19 @@ abc = secondAbcd; // missing 'd' abc = secondAb; // ok abc = secondCd; // missing 'd' abc = nope; // nope! -abc = decl; // ok +abc = decl; // bad - value of 'c' differs between these enums secondAbc = abc; // ok secondAbcd = abc; // ok secondAb = abc; // missing 'c' secondCd = abc; // missing 'a' and 'b' nope = abc; // nope! -decl = abc; // ok +decl = abc; // bad - value of 'c' differs between these enums // const is only assignable to itself k = k; abc = k; // error k = abc; // merged enums compare all their members abc = merged; // missing 'd' -merged = abc; // ok +merged = abc; // bad - value of 'c' differs between these enums abc = merged2; // ok merged2 = abc; // ok diff --git a/tests/baselines/reference/enumAssignmentCompat3.symbols b/tests/baselines/reference/enumAssignmentCompat3.symbols index 08b78e85f3a0d..00ee430fc60b3 100644 --- a/tests/baselines/reference/enumAssignmentCompat3.symbols +++ b/tests/baselines/reference/enumAssignmentCompat3.symbols @@ -200,7 +200,7 @@ abc = nope; // nope! >abc : Symbol(abc, Decl(enumAssignmentCompat3.ts, 56, 3)) >nope : Symbol(nope, Decl(enumAssignmentCompat3.ts, 61, 3)) -abc = decl; // ok +abc = decl; // bad - value of 'c' differs between these enums >abc : Symbol(abc, Decl(enumAssignmentCompat3.ts, 56, 3)) >decl : Symbol(decl, Decl(enumAssignmentCompat3.ts, 63, 3)) @@ -224,7 +224,7 @@ nope = abc; // nope! >nope : Symbol(nope, Decl(enumAssignmentCompat3.ts, 61, 3)) >abc : Symbol(abc, Decl(enumAssignmentCompat3.ts, 56, 3)) -decl = abc; // ok +decl = abc; // bad - value of 'c' differs between these enums >decl : Symbol(decl, Decl(enumAssignmentCompat3.ts, 63, 3)) >abc : Symbol(abc, Decl(enumAssignmentCompat3.ts, 56, 3)) @@ -246,7 +246,7 @@ abc = merged; // missing 'd' >abc : Symbol(abc, Decl(enumAssignmentCompat3.ts, 56, 3)) >merged : Symbol(merged, Decl(enumAssignmentCompat3.ts, 64, 3)) -merged = abc; // ok +merged = abc; // bad - value of 'c' differs between these enums >merged : Symbol(merged, Decl(enumAssignmentCompat3.ts, 64, 3)) >abc : Symbol(abc, Decl(enumAssignmentCompat3.ts, 56, 3)) diff --git a/tests/baselines/reference/enumAssignmentCompat3.types b/tests/baselines/reference/enumAssignmentCompat3.types index cc72b6777ba98..e1f98a739c8c9 100644 --- a/tests/baselines/reference/enumAssignmentCompat3.types +++ b/tests/baselines/reference/enumAssignmentCompat3.types @@ -196,7 +196,7 @@ abc = nope; // nope! >abc : First.E >nope : Abc.Nope -abc = decl; // ok +abc = decl; // bad - value of 'c' differs between these enums >abc = decl : Decl.E >abc : First.E >decl : Decl.E @@ -226,7 +226,7 @@ nope = abc; // nope! >nope : Abc.Nope >abc : First.E -decl = abc; // ok +decl = abc; // bad - value of 'c' differs between these enums >decl = abc : First.E >decl : Decl.E >abc : First.E @@ -253,7 +253,7 @@ abc = merged; // missing 'd' >abc : First.E >merged : Merged.E -merged = abc; // ok +merged = abc; // bad - value of 'c' differs between these enums >merged = abc : First.E >merged : Merged.E >abc : First.E diff --git a/tests/baselines/reference/enumAssignmentCompat6.errors.txt b/tests/baselines/reference/enumAssignmentCompat6.errors.txt new file mode 100644 index 0000000000000..6fa72a1d05f16 --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat6.errors.txt @@ -0,0 +1,115 @@ +f.ts(37,5): error TS2322: Type 'strings.DiagnosticCategory' is not assignable to type 'numerics.DiagnosticCategory'. + Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '0' was expected but '"Warning"' was given. +f.ts(38,5): error TS2322: Type 'numerics.DiagnosticCategory' is not assignable to type 'strings.DiagnosticCategory'. + Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '"Warning"' was expected but '0' was given. +f.ts(42,5): error TS2322: Type 'DiagnosticCategory' is not assignable to type 'DiagnosticCategory2'. +f.ts(43,5): error TS2322: Type 'DiagnosticCategory2' is not assignable to type 'DiagnosticCategory'. +f.ts(52,5): error TS2322: Type 'ambients.DiagnosticCategory' is not assignable to type 'strings.DiagnosticCategory'. + One value of 'DiagnosticCategory.Warning' is the string '"Warning"', and the other is assumed to be an unknown numeric value. +f.ts(53,5): error TS2322: Type 'strings.DiagnosticCategory' is not assignable to type 'ambients.DiagnosticCategory'. + One value of 'DiagnosticCategory.Warning' is the string '"Warning"', and the other is assumed to be an unknown numeric value. +f.ts(73,9): error TS2322: Type 'DiagnosticCategory' is not assignable to type 'import("f").DiagnosticCategory'. + Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '0' was expected but '"Warning"' was given. +f.ts(74,9): error TS2322: Type 'import("f").DiagnosticCategory' is not assignable to type 'DiagnosticCategory'. + Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '"Warning"' was expected but '0' was given. + + +==== f.ts (8 errors) ==== + // @filename a.ts + namespace numerics { + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } + + export enum DiagnosticCategory2 { + Warning, + Error, + Suggestion, + Message, + } + } + + namespace strings { + export enum DiagnosticCategory { + Warning = "Warning", + Error = "Error", + Suggestion = "Suggestion", + Message = "Message", + } + } + + declare namespace ambients { + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } + } + + function f(x: numerics.DiagnosticCategory, y: strings.DiagnosticCategory) { + x = y; + ~ +!!! error TS2322: Type 'strings.DiagnosticCategory' is not assignable to type 'numerics.DiagnosticCategory'. +!!! error TS2322: Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '0' was expected but '"Warning"' was given. + y = x; + ~ +!!! error TS2322: Type 'numerics.DiagnosticCategory' is not assignable to type 'strings.DiagnosticCategory'. +!!! error TS2322: Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '"Warning"' was expected but '0' was given. + } + + function g(x: numerics.DiagnosticCategory2, y: strings.DiagnosticCategory) { + x = y; + ~ +!!! error TS2322: Type 'DiagnosticCategory' is not assignable to type 'DiagnosticCategory2'. + y = x; + ~ +!!! error TS2322: Type 'DiagnosticCategory2' is not assignable to type 'DiagnosticCategory'. + } + + function h(x: numerics.DiagnosticCategory, y: ambients.DiagnosticCategory) { + x = y; + y = x; + } + + function i(x: strings.DiagnosticCategory, y: ambients.DiagnosticCategory) { + x = y; + ~ +!!! error TS2322: Type 'ambients.DiagnosticCategory' is not assignable to type 'strings.DiagnosticCategory'. +!!! error TS2322: One value of 'DiagnosticCategory.Warning' is the string '"Warning"', and the other is assumed to be an unknown numeric value. + y = x; + ~ +!!! error TS2322: Type 'strings.DiagnosticCategory' is not assignable to type 'ambients.DiagnosticCategory'. +!!! error TS2322: One value of 'DiagnosticCategory.Warning' is the string '"Warning"', and the other is assumed to be an unknown numeric value. + } + + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } + + export let x: DiagnosticCategory; + + (() => { + enum DiagnosticCategory { + Warning = "Warning", + Error = "Error", + Suggestion = "Suggestion", + Message = "Message", + } + function f(y: DiagnosticCategory) { + x = y; + ~ +!!! error TS2322: Type 'DiagnosticCategory' is not assignable to type 'import("f").DiagnosticCategory'. +!!! error TS2322: Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '0' was expected but '"Warning"' was given. + y = x; + ~ +!!! error TS2322: Type 'import("f").DiagnosticCategory' is not assignable to type 'DiagnosticCategory'. +!!! error TS2322: Each declaration of 'DiagnosticCategory.Warning' differs in its value, where '"Warning"' was expected but '0' was given. + } + })() \ No newline at end of file diff --git a/tests/baselines/reference/enumAssignmentCompat6.js b/tests/baselines/reference/enumAssignmentCompat6.js new file mode 100644 index 0000000000000..a8cde20aacf69 --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat6.js @@ -0,0 +1,148 @@ +//// [tests/cases/compiler/enumAssignmentCompat6.ts] //// + +//// [f.ts] +// @filename a.ts +namespace numerics { + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } + + export enum DiagnosticCategory2 { + Warning, + Error, + Suggestion, + Message, + } +} + +namespace strings { + export enum DiagnosticCategory { + Warning = "Warning", + Error = "Error", + Suggestion = "Suggestion", + Message = "Message", + } +} + +declare namespace ambients { + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } +} + +function f(x: numerics.DiagnosticCategory, y: strings.DiagnosticCategory) { + x = y; + y = x; +} + +function g(x: numerics.DiagnosticCategory2, y: strings.DiagnosticCategory) { + x = y; + y = x; +} + +function h(x: numerics.DiagnosticCategory, y: ambients.DiagnosticCategory) { + x = y; + y = x; +} + +function i(x: strings.DiagnosticCategory, y: ambients.DiagnosticCategory) { + x = y; + y = x; +} + +export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, +} + +export let x: DiagnosticCategory; + +(() => { + enum DiagnosticCategory { + Warning = "Warning", + Error = "Error", + Suggestion = "Suggestion", + Message = "Message", + } + function f(y: DiagnosticCategory) { + x = y; + y = x; + } +})() + +//// [f.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.x = exports.DiagnosticCategory = void 0; +// @filename a.ts +var numerics; +(function (numerics) { + var DiagnosticCategory; + (function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion"; + DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message"; + })(DiagnosticCategory = numerics.DiagnosticCategory || (numerics.DiagnosticCategory = {})); + var DiagnosticCategory2; + (function (DiagnosticCategory2) { + DiagnosticCategory2[DiagnosticCategory2["Warning"] = 0] = "Warning"; + DiagnosticCategory2[DiagnosticCategory2["Error"] = 1] = "Error"; + DiagnosticCategory2[DiagnosticCategory2["Suggestion"] = 2] = "Suggestion"; + DiagnosticCategory2[DiagnosticCategory2["Message"] = 3] = "Message"; + })(DiagnosticCategory2 = numerics.DiagnosticCategory2 || (numerics.DiagnosticCategory2 = {})); +})(numerics || (numerics = {})); +var strings; +(function (strings) { + var DiagnosticCategory; + (function (DiagnosticCategory) { + DiagnosticCategory["Warning"] = "Warning"; + DiagnosticCategory["Error"] = "Error"; + DiagnosticCategory["Suggestion"] = "Suggestion"; + DiagnosticCategory["Message"] = "Message"; + })(DiagnosticCategory = strings.DiagnosticCategory || (strings.DiagnosticCategory = {})); +})(strings || (strings = {})); +function f(x, y) { + x = y; + y = x; +} +function g(x, y) { + x = y; + y = x; +} +function h(x, y) { + x = y; + y = x; +} +function i(x, y) { + x = y; + y = x; +} +var DiagnosticCategory; +(function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion"; + DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message"; +})(DiagnosticCategory || (exports.DiagnosticCategory = DiagnosticCategory = {})); +(function () { + var DiagnosticCategory; + (function (DiagnosticCategory) { + DiagnosticCategory["Warning"] = "Warning"; + DiagnosticCategory["Error"] = "Error"; + DiagnosticCategory["Suggestion"] = "Suggestion"; + DiagnosticCategory["Message"] = "Message"; + })(DiagnosticCategory || (DiagnosticCategory = {})); + function f(y) { + exports.x = y; + y = exports.x; + } +})(); diff --git a/tests/baselines/reference/enumAssignmentCompat6.symbols b/tests/baselines/reference/enumAssignmentCompat6.symbols new file mode 100644 index 0000000000000..fcf2c4f1637f5 --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat6.symbols @@ -0,0 +1,202 @@ +//// [tests/cases/compiler/enumAssignmentCompat6.ts] //// + +=== f.ts === +// @filename a.ts +namespace numerics { +>numerics : Symbol(numerics, Decl(f.ts, 0, 0)) + + export enum DiagnosticCategory { +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 1, 20)) + + Warning, +>Warning : Symbol(DiagnosticCategory.Warning, Decl(f.ts, 2, 36)) + + Error, +>Error : Symbol(DiagnosticCategory.Error, Decl(f.ts, 3, 16)) + + Suggestion, +>Suggestion : Symbol(DiagnosticCategory.Suggestion, Decl(f.ts, 4, 14)) + + Message, +>Message : Symbol(DiagnosticCategory.Message, Decl(f.ts, 5, 19)) + } + + export enum DiagnosticCategory2 { +>DiagnosticCategory2 : Symbol(DiagnosticCategory2, Decl(f.ts, 7, 5)) + + Warning, +>Warning : Symbol(DiagnosticCategory2.Warning, Decl(f.ts, 9, 37)) + + Error, +>Error : Symbol(DiagnosticCategory2.Error, Decl(f.ts, 10, 16)) + + Suggestion, +>Suggestion : Symbol(DiagnosticCategory2.Suggestion, Decl(f.ts, 11, 14)) + + Message, +>Message : Symbol(DiagnosticCategory2.Message, Decl(f.ts, 12, 19)) + } +} + +namespace strings { +>strings : Symbol(strings, Decl(f.ts, 15, 1)) + + export enum DiagnosticCategory { +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 17, 19)) + + Warning = "Warning", +>Warning : Symbol(DiagnosticCategory.Warning, Decl(f.ts, 18, 36)) + + Error = "Error", +>Error : Symbol(DiagnosticCategory.Error, Decl(f.ts, 19, 28)) + + Suggestion = "Suggestion", +>Suggestion : Symbol(DiagnosticCategory.Suggestion, Decl(f.ts, 20, 24)) + + Message = "Message", +>Message : Symbol(DiagnosticCategory.Message, Decl(f.ts, 21, 34)) + } +} + +declare namespace ambients { +>ambients : Symbol(ambients, Decl(f.ts, 24, 1)) + + export enum DiagnosticCategory { +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 26, 28)) + + Warning, +>Warning : Symbol(DiagnosticCategory.Warning, Decl(f.ts, 27, 36)) + + Error, +>Error : Symbol(DiagnosticCategory.Error, Decl(f.ts, 28, 16)) + + Suggestion, +>Suggestion : Symbol(DiagnosticCategory.Suggestion, Decl(f.ts, 29, 14)) + + Message, +>Message : Symbol(DiagnosticCategory.Message, Decl(f.ts, 30, 19)) + } +} + +function f(x: numerics.DiagnosticCategory, y: strings.DiagnosticCategory) { +>f : Symbol(f, Decl(f.ts, 33, 1)) +>x : Symbol(x, Decl(f.ts, 35, 11)) +>numerics : Symbol(numerics, Decl(f.ts, 0, 0)) +>DiagnosticCategory : Symbol(numerics.DiagnosticCategory, Decl(f.ts, 1, 20)) +>y : Symbol(y, Decl(f.ts, 35, 42)) +>strings : Symbol(strings, Decl(f.ts, 15, 1)) +>DiagnosticCategory : Symbol(strings.DiagnosticCategory, Decl(f.ts, 17, 19)) + + x = y; +>x : Symbol(x, Decl(f.ts, 35, 11)) +>y : Symbol(y, Decl(f.ts, 35, 42)) + + y = x; +>y : Symbol(y, Decl(f.ts, 35, 42)) +>x : Symbol(x, Decl(f.ts, 35, 11)) +} + +function g(x: numerics.DiagnosticCategory2, y: strings.DiagnosticCategory) { +>g : Symbol(g, Decl(f.ts, 38, 1)) +>x : Symbol(x, Decl(f.ts, 40, 11)) +>numerics : Symbol(numerics, Decl(f.ts, 0, 0)) +>DiagnosticCategory2 : Symbol(numerics.DiagnosticCategory2, Decl(f.ts, 7, 5)) +>y : Symbol(y, Decl(f.ts, 40, 43)) +>strings : Symbol(strings, Decl(f.ts, 15, 1)) +>DiagnosticCategory : Symbol(strings.DiagnosticCategory, Decl(f.ts, 17, 19)) + + x = y; +>x : Symbol(x, Decl(f.ts, 40, 11)) +>y : Symbol(y, Decl(f.ts, 40, 43)) + + y = x; +>y : Symbol(y, Decl(f.ts, 40, 43)) +>x : Symbol(x, Decl(f.ts, 40, 11)) +} + +function h(x: numerics.DiagnosticCategory, y: ambients.DiagnosticCategory) { +>h : Symbol(h, Decl(f.ts, 43, 1)) +>x : Symbol(x, Decl(f.ts, 45, 11)) +>numerics : Symbol(numerics, Decl(f.ts, 0, 0)) +>DiagnosticCategory : Symbol(numerics.DiagnosticCategory, Decl(f.ts, 1, 20)) +>y : Symbol(y, Decl(f.ts, 45, 42)) +>ambients : Symbol(ambients, Decl(f.ts, 24, 1)) +>DiagnosticCategory : Symbol(ambients.DiagnosticCategory, Decl(f.ts, 26, 28)) + + x = y; +>x : Symbol(x, Decl(f.ts, 45, 11)) +>y : Symbol(y, Decl(f.ts, 45, 42)) + + y = x; +>y : Symbol(y, Decl(f.ts, 45, 42)) +>x : Symbol(x, Decl(f.ts, 45, 11)) +} + +function i(x: strings.DiagnosticCategory, y: ambients.DiagnosticCategory) { +>i : Symbol(i, Decl(f.ts, 48, 1)) +>x : Symbol(x, Decl(f.ts, 50, 11)) +>strings : Symbol(strings, Decl(f.ts, 15, 1)) +>DiagnosticCategory : Symbol(strings.DiagnosticCategory, Decl(f.ts, 17, 19)) +>y : Symbol(y, Decl(f.ts, 50, 41)) +>ambients : Symbol(ambients, Decl(f.ts, 24, 1)) +>DiagnosticCategory : Symbol(ambients.DiagnosticCategory, Decl(f.ts, 26, 28)) + + x = y; +>x : Symbol(x, Decl(f.ts, 50, 11)) +>y : Symbol(y, Decl(f.ts, 50, 41)) + + y = x; +>y : Symbol(y, Decl(f.ts, 50, 41)) +>x : Symbol(x, Decl(f.ts, 50, 11)) +} + +export enum DiagnosticCategory { +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 53, 1)) + + Warning, +>Warning : Symbol(DiagnosticCategory.Warning, Decl(f.ts, 55, 32)) + + Error, +>Error : Symbol(DiagnosticCategory.Error, Decl(f.ts, 56, 12)) + + Suggestion, +>Suggestion : Symbol(DiagnosticCategory.Suggestion, Decl(f.ts, 57, 10)) + + Message, +>Message : Symbol(DiagnosticCategory.Message, Decl(f.ts, 58, 15)) +} + +export let x: DiagnosticCategory; +>x : Symbol(x, Decl(f.ts, 62, 10)) +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 53, 1)) + +(() => { + enum DiagnosticCategory { +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 64, 8)) + + Warning = "Warning", +>Warning : Symbol(DiagnosticCategory.Warning, Decl(f.ts, 65, 29)) + + Error = "Error", +>Error : Symbol(DiagnosticCategory.Error, Decl(f.ts, 66, 28)) + + Suggestion = "Suggestion", +>Suggestion : Symbol(DiagnosticCategory.Suggestion, Decl(f.ts, 67, 24)) + + Message = "Message", +>Message : Symbol(DiagnosticCategory.Message, Decl(f.ts, 68, 34)) + } + function f(y: DiagnosticCategory) { +>f : Symbol(f, Decl(f.ts, 70, 5)) +>y : Symbol(y, Decl(f.ts, 71, 15)) +>DiagnosticCategory : Symbol(DiagnosticCategory, Decl(f.ts, 64, 8)) + + x = y; +>x : Symbol(x, Decl(f.ts, 62, 10)) +>y : Symbol(y, Decl(f.ts, 71, 15)) + + y = x; +>y : Symbol(y, Decl(f.ts, 71, 15)) +>x : Symbol(x, Decl(f.ts, 62, 10)) + } +})() diff --git a/tests/baselines/reference/enumAssignmentCompat6.types b/tests/baselines/reference/enumAssignmentCompat6.types new file mode 100644 index 0000000000000..ff464f41afb28 --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat6.types @@ -0,0 +1,214 @@ +//// [tests/cases/compiler/enumAssignmentCompat6.ts] //// + +=== f.ts === +// @filename a.ts +namespace numerics { +>numerics : typeof numerics + + export enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning, +>Warning : DiagnosticCategory.Warning + + Error, +>Error : DiagnosticCategory.Error + + Suggestion, +>Suggestion : DiagnosticCategory.Suggestion + + Message, +>Message : DiagnosticCategory.Message + } + + export enum DiagnosticCategory2 { +>DiagnosticCategory2 : DiagnosticCategory2 + + Warning, +>Warning : DiagnosticCategory2.Warning + + Error, +>Error : DiagnosticCategory2.Error + + Suggestion, +>Suggestion : DiagnosticCategory2.Suggestion + + Message, +>Message : DiagnosticCategory2.Message + } +} + +namespace strings { +>strings : typeof strings + + export enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning = "Warning", +>Warning : DiagnosticCategory.Warning +>"Warning" : "Warning" + + Error = "Error", +>Error : DiagnosticCategory.Error +>"Error" : "Error" + + Suggestion = "Suggestion", +>Suggestion : DiagnosticCategory.Suggestion +>"Suggestion" : "Suggestion" + + Message = "Message", +>Message : DiagnosticCategory.Message +>"Message" : "Message" + } +} + +declare namespace ambients { +>ambients : typeof ambients + + export enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning, +>Warning : DiagnosticCategory.Warning + + Error, +>Error : DiagnosticCategory.Error + + Suggestion, +>Suggestion : DiagnosticCategory.Suggestion + + Message, +>Message : DiagnosticCategory.Message + } +} + +function f(x: numerics.DiagnosticCategory, y: strings.DiagnosticCategory) { +>f : (x: numerics.DiagnosticCategory, y: strings.DiagnosticCategory) => void +>x : numerics.DiagnosticCategory +>numerics : any +>y : strings.DiagnosticCategory +>strings : any + + x = y; +>x = y : strings.DiagnosticCategory +>x : numerics.DiagnosticCategory +>y : strings.DiagnosticCategory + + y = x; +>y = x : numerics.DiagnosticCategory +>y : strings.DiagnosticCategory +>x : numerics.DiagnosticCategory +} + +function g(x: numerics.DiagnosticCategory2, y: strings.DiagnosticCategory) { +>g : (x: numerics.DiagnosticCategory2, y: strings.DiagnosticCategory) => void +>x : numerics.DiagnosticCategory2 +>numerics : any +>y : strings.DiagnosticCategory +>strings : any + + x = y; +>x = y : strings.DiagnosticCategory +>x : numerics.DiagnosticCategory2 +>y : strings.DiagnosticCategory + + y = x; +>y = x : numerics.DiagnosticCategory2 +>y : strings.DiagnosticCategory +>x : numerics.DiagnosticCategory2 +} + +function h(x: numerics.DiagnosticCategory, y: ambients.DiagnosticCategory) { +>h : (x: numerics.DiagnosticCategory, y: ambients.DiagnosticCategory) => void +>x : numerics.DiagnosticCategory +>numerics : any +>y : ambients.DiagnosticCategory +>ambients : any + + x = y; +>x = y : ambients.DiagnosticCategory +>x : numerics.DiagnosticCategory +>y : ambients.DiagnosticCategory + + y = x; +>y = x : numerics.DiagnosticCategory +>y : ambients.DiagnosticCategory +>x : numerics.DiagnosticCategory +} + +function i(x: strings.DiagnosticCategory, y: ambients.DiagnosticCategory) { +>i : (x: strings.DiagnosticCategory, y: ambients.DiagnosticCategory) => void +>x : strings.DiagnosticCategory +>strings : any +>y : ambients.DiagnosticCategory +>ambients : any + + x = y; +>x = y : ambients.DiagnosticCategory +>x : strings.DiagnosticCategory +>y : ambients.DiagnosticCategory + + y = x; +>y = x : strings.DiagnosticCategory +>y : ambients.DiagnosticCategory +>x : strings.DiagnosticCategory +} + +export enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning, +>Warning : DiagnosticCategory.Warning + + Error, +>Error : DiagnosticCategory.Error + + Suggestion, +>Suggestion : DiagnosticCategory.Suggestion + + Message, +>Message : DiagnosticCategory.Message +} + +export let x: DiagnosticCategory; +>x : DiagnosticCategory + +(() => { +>(() => { enum DiagnosticCategory { Warning = "Warning", Error = "Error", Suggestion = "Suggestion", Message = "Message", } function f(y: DiagnosticCategory) { x = y; y = x; }})() : void +>(() => { enum DiagnosticCategory { Warning = "Warning", Error = "Error", Suggestion = "Suggestion", Message = "Message", } function f(y: DiagnosticCategory) { x = y; y = x; }}) : () => void +>() => { enum DiagnosticCategory { Warning = "Warning", Error = "Error", Suggestion = "Suggestion", Message = "Message", } function f(y: DiagnosticCategory) { x = y; y = x; }} : () => void + + enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning = "Warning", +>Warning : DiagnosticCategory.Warning +>"Warning" : "Warning" + + Error = "Error", +>Error : DiagnosticCategory.Error +>"Error" : "Error" + + Suggestion = "Suggestion", +>Suggestion : DiagnosticCategory.Suggestion +>"Suggestion" : "Suggestion" + + Message = "Message", +>Message : DiagnosticCategory.Message +>"Message" : "Message" + } + function f(y: DiagnosticCategory) { +>f : (y: DiagnosticCategory) => void +>y : DiagnosticCategory + + x = y; +>x = y : DiagnosticCategory +>x : import("f").DiagnosticCategory +>y : DiagnosticCategory + + y = x; +>y = x : import("f").DiagnosticCategory +>y : DiagnosticCategory +>x : import("f").DiagnosticCategory + } +})() diff --git a/tests/baselines/reference/enumAssignmentCompat7.errors.txt b/tests/baselines/reference/enumAssignmentCompat7.errors.txt new file mode 100644 index 0000000000000..b829d9b65dcdd --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat7.errors.txt @@ -0,0 +1,42 @@ +enumAssignmentCompat7.ts(16,14): error TS2416: Property 'method' in type 'Derived' is not assignable to the same property in base type 'Base'. + Type '(param: second.E) => void' is not assignable to type '(param: first.E) => void'. + Types of parameters 'param' and 'param' are incompatible. + Type 'first.E' is not assignable to type 'second.E'. +enumAssignmentCompat7.ts(20,10): error TS2394: This overload signature is not compatible with its implementation signature. +enumAssignmentCompat7.ts(22,21): error TS2339: Property 'B' does not exist on type 'typeof E'. + + +==== enumAssignmentCompat7.ts (3 errors) ==== + namespace first { + export enum E { A = 1 } + } + + namespace second { + export enum E { A = 2 } + } + + class Base { + method(param: first.E) { + + } + } + + class Derived extends Base { + override method(param: second.E) { + ~~~~~~ +!!! error TS2416: Property 'method' in type 'Derived' is not assignable to the same property in base type 'Base'. +!!! error TS2416: Type '(param: second.E) => void' is not assignable to type '(param: first.E) => void'. +!!! error TS2416: Types of parameters 'param' and 'param' are incompatible. +!!! error TS2416: Type 'first.E' is not assignable to type 'second.E'. + } + } + + function overloadingFunction(): first.E + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2394: This overload signature is not compatible with its implementation signature. +!!! related TS2750 enumAssignmentCompat7.ts:21:10: The implementation signature is declared here. + function overloadingFunction(): second.E { + return second.E.B + ~ +!!! error TS2339: Property 'B' does not exist on type 'typeof E'. + } \ No newline at end of file diff --git a/tests/baselines/reference/enumAssignmentCompat7.js b/tests/baselines/reference/enumAssignmentCompat7.js new file mode 100644 index 0000000000000..4521732abed6d --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat7.js @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/enumAssignmentCompat7.ts] //// + +//// [enumAssignmentCompat7.ts] +namespace first { + export enum E { A = 1 } +} + +namespace second { + export enum E { A = 2 } +} + +class Base { + method(param: first.E) { + + } +} + +class Derived extends Base { + override method(param: second.E) { + } +} + +function overloadingFunction(): first.E +function overloadingFunction(): second.E { + return second.E.B +} + +//// [enumAssignmentCompat7.js] +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var first; +(function (first) { + var E; + (function (E) { + E[E["A"] = 1] = "A"; + })(E = first.E || (first.E = {})); +})(first || (first = {})); +var second; +(function (second) { + var E; + (function (E) { + E[E["A"] = 2] = "A"; + })(E = second.E || (second.E = {})); +})(second || (second = {})); +var Base = /** @class */ (function () { + function Base() { + } + Base.prototype.method = function (param) { + }; + return Base; +}()); +var Derived = /** @class */ (function (_super) { + __extends(Derived, _super); + function Derived() { + return _super !== null && _super.apply(this, arguments) || this; + } + Derived.prototype.method = function (param) { + }; + return Derived; +}(Base)); +function overloadingFunction() { + return second.E.B; +} diff --git a/tests/baselines/reference/enumAssignmentCompat7.symbols b/tests/baselines/reference/enumAssignmentCompat7.symbols new file mode 100644 index 0000000000000..8cd0dd808a94a --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat7.symbols @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/enumAssignmentCompat7.ts] //// + +=== enumAssignmentCompat7.ts === +namespace first { +>first : Symbol(first, Decl(enumAssignmentCompat7.ts, 0, 0)) + + export enum E { A = 1 } +>E : Symbol(E, Decl(enumAssignmentCompat7.ts, 0, 17)) +>A : Symbol(E.A, Decl(enumAssignmentCompat7.ts, 1, 19)) +} + +namespace second { +>second : Symbol(second, Decl(enumAssignmentCompat7.ts, 2, 1)) + + export enum E { A = 2 } +>E : Symbol(E, Decl(enumAssignmentCompat7.ts, 4, 18)) +>A : Symbol(E.A, Decl(enumAssignmentCompat7.ts, 5, 19)) +} + +class Base { +>Base : Symbol(Base, Decl(enumAssignmentCompat7.ts, 6, 1)) + + method(param: first.E) { +>method : Symbol(Base.method, Decl(enumAssignmentCompat7.ts, 8, 12)) +>param : Symbol(param, Decl(enumAssignmentCompat7.ts, 9, 11)) +>first : Symbol(first, Decl(enumAssignmentCompat7.ts, 0, 0)) +>E : Symbol(first.E, Decl(enumAssignmentCompat7.ts, 0, 17)) + + } +} + +class Derived extends Base { +>Derived : Symbol(Derived, Decl(enumAssignmentCompat7.ts, 12, 1)) +>Base : Symbol(Base, Decl(enumAssignmentCompat7.ts, 6, 1)) + + override method(param: second.E) { +>method : Symbol(Derived.method, Decl(enumAssignmentCompat7.ts, 14, 28)) +>param : Symbol(param, Decl(enumAssignmentCompat7.ts, 15, 20)) +>second : Symbol(second, Decl(enumAssignmentCompat7.ts, 2, 1)) +>E : Symbol(second.E, Decl(enumAssignmentCompat7.ts, 4, 18)) + } +} + +function overloadingFunction(): first.E +>overloadingFunction : Symbol(overloadingFunction, Decl(enumAssignmentCompat7.ts, 17, 1), Decl(enumAssignmentCompat7.ts, 19, 39)) +>first : Symbol(first, Decl(enumAssignmentCompat7.ts, 0, 0)) +>E : Symbol(first.E, Decl(enumAssignmentCompat7.ts, 0, 17)) + +function overloadingFunction(): second.E { +>overloadingFunction : Symbol(overloadingFunction, Decl(enumAssignmentCompat7.ts, 17, 1), Decl(enumAssignmentCompat7.ts, 19, 39)) +>second : Symbol(second, Decl(enumAssignmentCompat7.ts, 2, 1)) +>E : Symbol(second.E, Decl(enumAssignmentCompat7.ts, 4, 18)) + + return second.E.B +>second.E : Symbol(second.E, Decl(enumAssignmentCompat7.ts, 4, 18)) +>second : Symbol(second, Decl(enumAssignmentCompat7.ts, 2, 1)) +>E : Symbol(second.E, Decl(enumAssignmentCompat7.ts, 4, 18)) +} diff --git a/tests/baselines/reference/enumAssignmentCompat7.types b/tests/baselines/reference/enumAssignmentCompat7.types new file mode 100644 index 0000000000000..0445ae8147ac4 --- /dev/null +++ b/tests/baselines/reference/enumAssignmentCompat7.types @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/enumAssignmentCompat7.ts] //// + +=== enumAssignmentCompat7.ts === +namespace first { +>first : typeof first + + export enum E { A = 1 } +>E : E +>A : E.A +>1 : 1 +} + +namespace second { +>second : typeof second + + export enum E { A = 2 } +>E : E +>A : E.A +>2 : 2 +} + +class Base { +>Base : Base + + method(param: first.E) { +>method : (param: first.E) => void +>param : first.E +>first : any + + } +} + +class Derived extends Base { +>Derived : Derived +>Base : Base + + override method(param: second.E) { +>method : (param: second.E) => void +>param : second.E +>second : any + } +} + +function overloadingFunction(): first.E +>overloadingFunction : () => first.E +>first : any + +function overloadingFunction(): second.E { +>overloadingFunction : () => first.E +>second : any + + return second.E.B +>second.E.B : any +>second.E : typeof second.E +>second : typeof second +>E : typeof second.E +>B : any +} diff --git a/tests/cases/compiler/enumAssignmentCompat3.ts b/tests/cases/compiler/enumAssignmentCompat3.ts index 97a136468e3ee..a706be4ce2176 100644 --- a/tests/cases/compiler/enumAssignmentCompat3.ts +++ b/tests/cases/compiler/enumAssignmentCompat3.ts @@ -69,13 +69,13 @@ abc = secondAbcd; // missing 'd' abc = secondAb; // ok abc = secondCd; // missing 'd' abc = nope; // nope! -abc = decl; // ok +abc = decl; // bad - value of 'c' differs between these enums secondAbc = abc; // ok secondAbcd = abc; // ok secondAb = abc; // missing 'c' secondCd = abc; // missing 'a' and 'b' nope = abc; // nope! -decl = abc; // ok +decl = abc; // bad - value of 'c' differs between these enums // const is only assignable to itself k = k; @@ -84,6 +84,6 @@ k = abc; // merged enums compare all their members abc = merged; // missing 'd' -merged = abc; // ok +merged = abc; // bad - value of 'c' differs between these enums abc = merged2; // ok merged2 = abc; // ok \ No newline at end of file diff --git a/tests/cases/compiler/enumAssignmentCompat6.ts b/tests/cases/compiler/enumAssignmentCompat6.ts new file mode 100644 index 0000000000000..b91300d37c537 --- /dev/null +++ b/tests/cases/compiler/enumAssignmentCompat6.ts @@ -0,0 +1,77 @@ +// @filename a.ts +namespace numerics { + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } + + export enum DiagnosticCategory2 { + Warning, + Error, + Suggestion, + Message, + } +} + +namespace strings { + export enum DiagnosticCategory { + Warning = "Warning", + Error = "Error", + Suggestion = "Suggestion", + Message = "Message", + } +} + +declare namespace ambients { + export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, + } +} + +function f(x: numerics.DiagnosticCategory, y: strings.DiagnosticCategory) { + x = y; + y = x; +} + +function g(x: numerics.DiagnosticCategory2, y: strings.DiagnosticCategory) { + x = y; + y = x; +} + +function h(x: numerics.DiagnosticCategory, y: ambients.DiagnosticCategory) { + x = y; + y = x; +} + +function i(x: strings.DiagnosticCategory, y: ambients.DiagnosticCategory) { + x = y; + y = x; +} + +// @filename: f.ts +export enum DiagnosticCategory { + Warning, + Error, + Suggestion, + Message, +} + +export let x: DiagnosticCategory; + +(() => { + enum DiagnosticCategory { + Warning = "Warning", + Error = "Error", + Suggestion = "Suggestion", + Message = "Message", + } + function f(y: DiagnosticCategory) { + x = y; + y = x; + } +})() \ No newline at end of file diff --git a/tests/cases/compiler/enumAssignmentCompat7.ts b/tests/cases/compiler/enumAssignmentCompat7.ts new file mode 100644 index 0000000000000..179f7d844dbfb --- /dev/null +++ b/tests/cases/compiler/enumAssignmentCompat7.ts @@ -0,0 +1,26 @@ +// @strict: true +// @strictFunctionTypes: false + +namespace first { + export enum E { A = 1 } +} + +namespace second { + export enum E { A = 2 } +} + +class Base { + method(param: first.E) { + + } +} + +class Derived extends Base { + override method(param: second.E) { + } +} + +function overloadingFunction(): first.E +function overloadingFunction(): second.E { + return second.E.B +} \ No newline at end of file