From 0c37e7c157815a4f5e20fbfc3ebe7f41d830f16e Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Thu, 25 May 2023 17:43:12 +0300 Subject: [PATCH 1/9] feat(typescript-estree): split TSMappedType typeParameter into constraint and key --- .../snapshots/1-TSESTree-AST.shot | 98 ++++++------- .../snapshots/5-AST-Alignment-AST.shot | 136 +++++++++++------- .../snapshots/1-TSESTree-AST.shot | 54 +++---- .../snapshots/5-AST-Alignment-AST.shot | 72 +++++----- .../snapshots/1-TSESTree-AST.shot | 54 +++---- .../snapshots/5-AST-Alignment-AST.shot | 72 +++++----- .../snapshots/1-TSESTree-AST.shot | 54 +++---- .../snapshots/5-AST-Alignment-AST.shot | 72 +++++----- .../snapshots/1-TSESTree-AST.shot | 42 ++---- .../snapshots/5-AST-Alignment-AST.shot | 55 ++++--- .../mapped/snapshots/1-TSESTree-AST.shot | 54 +++---- .../mapped/snapshots/5-AST-Alignment-AST.shot | 76 +++++----- .../ast-spec/src/type/TSMappedType/spec.ts | 6 + packages/typescript-estree/src/convert.ts | 83 +++++++++-- .../tests/lib/convert.test.ts | 96 ++++++++++++- 15 files changed, 574 insertions(+), 450 deletions(-) diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/1-TSESTree-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/1-TSESTree-AST.shot index ef00d6dd163a..57cd9d3e565c 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/1-TSESTree-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/1-TSESTree-AST.shot @@ -21,6 +21,49 @@ Program { }, typeAnnotation: TSMappedType { type: "TSMappedType", + constraint: TSTypeOperator { + type: "TSTypeOperator", + operator: "keyof", + typeAnnotation: TSTypeReference { + type: "TSTypeReference", + typeName: Identifier { + type: "Identifier", + decorators: [], + name: "T", + optional: false, + + range: [104, 105], + loc: { + start: { column: 14, line: 4 }, + end: { column: 15, line: 4 }, + }, + }, + + range: [104, 105], + loc: { + start: { column: 14, line: 4 }, + end: { column: 15, line: 4 }, + }, + }, + + range: [98, 105], + loc: { + start: { column: 8, line: 4 }, + end: { column: 15, line: 4 }, + }, + }, + key: Identifier { + type: "Identifier", + decorators: [], + name: "P", + optional: false, + + range: [93, 94], + loc: { + start: { column: 3, line: 4 }, + end: { column: 4, line: 4 }, + }, + }, nameType: TSLiteralType { type: "TSLiteralType", literal: Literal { @@ -92,61 +135,6 @@ Program { end: { column: 29, line: 4 }, }, }, - typeParameter: TSTypeParameter { - type: "TSTypeParameter", - const: false, - constraint: TSTypeOperator { - type: "TSTypeOperator", - operator: "keyof", - typeAnnotation: TSTypeReference { - type: "TSTypeReference", - typeName: Identifier { - type: "Identifier", - decorators: [], - name: "T", - optional: false, - - range: [104, 105], - loc: { - start: { column: 14, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, - - range: [104, 105], - loc: { - start: { column: 14, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, - - range: [98, 105], - loc: { - start: { column: 8, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, - in: false, - name: Identifier { - type: "Identifier", - decorators: [], - name: "P", - optional: false, - - range: [93, 94], - loc: { - start: { column: 3, line: 4 }, - end: { column: 4, line: 4 }, - }, - }, - out: false, - - range: [93, 105], - loc: { - start: { column: 3, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, range: [88, 122], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/5-AST-Alignment-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/5-AST-Alignment-AST.shot index 368c485e82da..3c7484cb3764 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/5-AST-Alignment-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-named-type/snapshots/5-AST-Alignment-AST.shot @@ -25,6 +25,49 @@ exports[`AST Fixtures legacy-fixtures types mapped-named-type AST Alignment - AS }, typeAnnotation: TSMappedType { type: 'TSMappedType', +- constraint: TSTypeOperator { +- type: 'TSTypeOperator', +- operator: 'keyof', +- typeAnnotation: TSTypeReference { +- type: 'TSTypeReference', +- typeName: Identifier { +- type: 'Identifier', +- decorators: Array [], +- name: 'T', +- optional: false, +- +- range: [104, 105], +- loc: { +- start: { column: 14, line: 4 }, +- end: { column: 15, line: 4 }, +- }, +- }, +- +- range: [104, 105], +- loc: { +- start: { column: 14, line: 4 }, +- end: { column: 15, line: 4 }, +- }, +- }, +- +- range: [98, 105], +- loc: { +- start: { column: 8, line: 4 }, +- end: { column: 15, line: 4 }, +- }, +- }, +- key: Identifier { +- type: 'Identifier', +- decorators: Array [], +- name: 'P', +- optional: false, +- +- range: [93, 94], +- loc: { +- start: { column: 3, line: 4 }, +- end: { column: 4, line: 4 }, +- }, +- }, nameType: TSLiteralType { type: 'TSLiteralType', literal: Literal { @@ -96,62 +139,45 @@ exports[`AST Fixtures legacy-fixtures types mapped-named-type AST Alignment - AS end: { column: 29, line: 4 }, }, }, - typeParameter: TSTypeParameter { - type: 'TSTypeParameter', -- const: false, - constraint: TSTypeOperator { - type: 'TSTypeOperator', - operator: 'keyof', - typeAnnotation: TSTypeReference { - type: 'TSTypeReference', - typeName: Identifier { - type: 'Identifier', -- decorators: Array [], - name: 'T', -- optional: false, - - range: [104, 105], - loc: { - start: { column: 14, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, - - range: [104, 105], - loc: { - start: { column: 14, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, - - range: [98, 105], - loc: { - start: { column: 8, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, -- in: false, -- name: Identifier { -- type: 'Identifier', -- decorators: Array [], -- name: 'P', -- optional: false, -- -- range: [93, 94], -- loc: { -- start: { column: 3, line: 4 }, -- end: { column: 4, line: 4 }, -- }, -- }, -- out: false, ++ typeParameter: TSTypeParameter { ++ type: 'TSTypeParameter', ++ constraint: TSTypeOperator { ++ type: 'TSTypeOperator', ++ operator: 'keyof', ++ typeAnnotation: TSTypeReference { ++ type: 'TSTypeReference', ++ typeName: Identifier { ++ type: 'Identifier', ++ name: 'T', ++ ++ range: [104, 105], ++ loc: { ++ start: { column: 14, line: 4 }, ++ end: { column: 15, line: 4 }, ++ }, ++ }, ++ ++ range: [104, 105], ++ loc: { ++ start: { column: 14, line: 4 }, ++ end: { column: 15, line: 4 }, ++ }, ++ }, ++ ++ range: [98, 105], ++ loc: { ++ start: { column: 8, line: 4 }, ++ end: { column: 15, line: 4 }, ++ }, ++ }, + name: 'P', - - range: [93, 105], - loc: { - start: { column: 3, line: 4 }, - end: { column: 15, line: 4 }, - }, - }, ++ ++ range: [93, 105], ++ loc: { ++ start: { column: 3, line: 4 }, ++ end: { column: 15, line: 4 }, ++ }, ++ }, range: [88, 122], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/1-TSESTree-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/1-TSESTree-AST.shot index 5e7781c3ef65..3ddeb8b5a60c 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/1-TSESTree-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/1-TSESTree-AST.shot @@ -19,6 +19,27 @@ Program { type: "TSTypeAnnotation", typeAnnotation: TSMappedType { type: "TSMappedType", + constraint: TSStringKeyword { + type: "TSStringKeyword", + + range: [100, 106], + loc: { + start: { column: 27, line: 3 }, + end: { column: 33, line: 3 }, + }, + }, + key: Identifier { + type: "Identifier", + decorators: [], + name: "P", + optional: false, + + range: [95, 96], + loc: { + start: { column: 22, line: 3 }, + end: { column: 23, line: 3 }, + }, + }, nameType: null, optional: "-", readonly: "-", @@ -31,39 +52,6 @@ Program { end: { column: 44, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: "TSTypeParameter", - const: false, - constraint: TSStringKeyword { - type: "TSStringKeyword", - - range: [100, 106], - loc: { - start: { column: 27, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, - in: false, - name: Identifier { - type: "Identifier", - decorators: [], - name: "P", - optional: false, - - range: [95, 96], - loc: { - start: { column: 22, line: 3 }, - end: { column: 23, line: 3 }, - }, - }, - out: false, - - range: [95, 106], - loc: { - start: { column: 22, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, range: [82, 119], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/5-AST-Alignment-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/5-AST-Alignment-AST.shot index 5a1e7b20c516..be92a34ed653 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/5-AST-Alignment-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-minus/snapshots/5-AST-Alignment-AST.shot @@ -23,6 +23,27 @@ exports[`AST Fixtures legacy-fixtures types mapped-readonly-minus AST Alignment type: 'TSTypeAnnotation', typeAnnotation: TSMappedType { type: 'TSMappedType', +- constraint: TSStringKeyword { +- type: 'TSStringKeyword', +- +- range: [100, 106], +- loc: { +- start: { column: 27, line: 3 }, +- end: { column: 33, line: 3 }, +- }, +- }, +- key: Identifier { +- type: 'Identifier', +- decorators: Array [], +- name: 'P', +- optional: false, +- +- range: [95, 96], +- loc: { +- start: { column: 22, line: 3 }, +- end: { column: 23, line: 3 }, +- }, +- }, nameType: null, optional: '-', readonly: '-', @@ -35,41 +56,26 @@ exports[`AST Fixtures legacy-fixtures types mapped-readonly-minus AST Alignment end: { column: 44, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: 'TSTypeParameter', -- const: false, - constraint: TSStringKeyword { - type: 'TSStringKeyword', ++ typeParameter: TSTypeParameter { ++ type: 'TSTypeParameter', ++ constraint: TSStringKeyword { ++ type: 'TSStringKeyword', - range: [100, 106], - loc: { - start: { column: 27, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, -- in: false, -- name: Identifier { -- type: 'Identifier', -- decorators: Array [], -- name: 'P', -- optional: false, ++ range: [100, 106], ++ loc: { ++ start: { column: 27, line: 3 }, ++ end: { column: 33, line: 3 }, ++ }, ++ }, + name: 'P', - -- range: [95, 96], -- loc: { -- start: { column: 22, line: 3 }, -- end: { column: 23, line: 3 }, -- }, -- }, -- out: false, -- - range: [95, 106], - loc: { - start: { column: 22, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, - ++ ++ range: [95, 106], ++ loc: { ++ start: { column: 22, line: 3 }, ++ end: { column: 33, line: 3 }, ++ }, ++ }, ++ range: [82, 119], loc: { start: { column: 9, line: 3 }, diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/1-TSESTree-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/1-TSESTree-AST.shot index fcdef4d6c306..0f3690a03bbb 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/1-TSESTree-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/1-TSESTree-AST.shot @@ -19,6 +19,27 @@ Program { type: "TSTypeAnnotation", typeAnnotation: TSMappedType { type: "TSMappedType", + constraint: TSStringKeyword { + type: "TSStringKeyword", + + range: [100, 106], + loc: { + start: { column: 27, line: 3 }, + end: { column: 33, line: 3 }, + }, + }, + key: Identifier { + type: "Identifier", + decorators: [], + name: "P", + optional: false, + + range: [95, 96], + loc: { + start: { column: 22, line: 3 }, + end: { column: 23, line: 3 }, + }, + }, nameType: null, optional: "+", readonly: "+", @@ -31,39 +52,6 @@ Program { end: { column: 44, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: "TSTypeParameter", - const: false, - constraint: TSStringKeyword { - type: "TSStringKeyword", - - range: [100, 106], - loc: { - start: { column: 27, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, - in: false, - name: Identifier { - type: "Identifier", - decorators: [], - name: "P", - optional: false, - - range: [95, 96], - loc: { - start: { column: 22, line: 3 }, - end: { column: 23, line: 3 }, - }, - }, - out: false, - - range: [95, 106], - loc: { - start: { column: 22, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, range: [82, 119], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/5-AST-Alignment-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/5-AST-Alignment-AST.shot index 6beae1721224..9dd0ad409179 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/5-AST-Alignment-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly-plus/snapshots/5-AST-Alignment-AST.shot @@ -23,6 +23,27 @@ exports[`AST Fixtures legacy-fixtures types mapped-readonly-plus AST Alignment - type: 'TSTypeAnnotation', typeAnnotation: TSMappedType { type: 'TSMappedType', +- constraint: TSStringKeyword { +- type: 'TSStringKeyword', +- +- range: [100, 106], +- loc: { +- start: { column: 27, line: 3 }, +- end: { column: 33, line: 3 }, +- }, +- }, +- key: Identifier { +- type: 'Identifier', +- decorators: Array [], +- name: 'P', +- optional: false, +- +- range: [95, 96], +- loc: { +- start: { column: 22, line: 3 }, +- end: { column: 23, line: 3 }, +- }, +- }, nameType: null, optional: '+', readonly: '+', @@ -35,41 +56,26 @@ exports[`AST Fixtures legacy-fixtures types mapped-readonly-plus AST Alignment - end: { column: 44, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: 'TSTypeParameter', -- const: false, - constraint: TSStringKeyword { - type: 'TSStringKeyword', ++ typeParameter: TSTypeParameter { ++ type: 'TSTypeParameter', ++ constraint: TSStringKeyword { ++ type: 'TSStringKeyword', - range: [100, 106], - loc: { - start: { column: 27, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, -- in: false, -- name: Identifier { -- type: 'Identifier', -- decorators: Array [], -- name: 'P', -- optional: false, ++ range: [100, 106], ++ loc: { ++ start: { column: 27, line: 3 }, ++ end: { column: 33, line: 3 }, ++ }, ++ }, + name: 'P', - -- range: [95, 96], -- loc: { -- start: { column: 22, line: 3 }, -- end: { column: 23, line: 3 }, -- }, -- }, -- out: false, -- - range: [95, 106], - loc: { - start: { column: 22, line: 3 }, - end: { column: 33, line: 3 }, - }, - }, - ++ ++ range: [95, 106], ++ loc: { ++ start: { column: 22, line: 3 }, ++ end: { column: 33, line: 3 }, ++ }, ++ }, ++ range: [82, 119], loc: { start: { column: 9, line: 3 }, diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/1-TSESTree-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/1-TSESTree-AST.shot index f70b1ed6956b..c28ad65a923f 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/1-TSESTree-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/1-TSESTree-AST.shot @@ -19,6 +19,27 @@ Program { type: "TSTypeAnnotation", typeAnnotation: TSMappedType { type: "TSMappedType", + constraint: TSStringKeyword { + type: "TSStringKeyword", + + range: [99, 105], + loc: { + start: { column: 26, line: 3 }, + end: { column: 32, line: 3 }, + }, + }, + key: Identifier { + type: "Identifier", + decorators: [], + name: "P", + optional: false, + + range: [94, 95], + loc: { + start: { column: 21, line: 3 }, + end: { column: 22, line: 3 }, + }, + }, nameType: null, optional: true, readonly: true, @@ -31,39 +52,6 @@ Program { end: { column: 42, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: "TSTypeParameter", - const: false, - constraint: TSStringKeyword { - type: "TSStringKeyword", - - range: [99, 105], - loc: { - start: { column: 26, line: 3 }, - end: { column: 32, line: 3 }, - }, - }, - in: false, - name: Identifier { - type: "Identifier", - decorators: [], - name: "P", - optional: false, - - range: [94, 95], - loc: { - start: { column: 21, line: 3 }, - end: { column: 22, line: 3 }, - }, - }, - out: false, - - range: [94, 105], - loc: { - start: { column: 21, line: 3 }, - end: { column: 32, line: 3 }, - }, - }, range: [82, 117], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/5-AST-Alignment-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/5-AST-Alignment-AST.shot index 8c8500647fd6..af26bcceb36b 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/5-AST-Alignment-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-readonly/snapshots/5-AST-Alignment-AST.shot @@ -23,6 +23,27 @@ exports[`AST Fixtures legacy-fixtures types mapped-readonly AST Alignment - AST type: 'TSTypeAnnotation', typeAnnotation: TSMappedType { type: 'TSMappedType', +- constraint: TSStringKeyword { +- type: 'TSStringKeyword', +- +- range: [99, 105], +- loc: { +- start: { column: 26, line: 3 }, +- end: { column: 32, line: 3 }, +- }, +- }, +- key: Identifier { +- type: 'Identifier', +- decorators: Array [], +- name: 'P', +- optional: false, +- +- range: [94, 95], +- loc: { +- start: { column: 21, line: 3 }, +- end: { column: 22, line: 3 }, +- }, +- }, nameType: null, optional: true, readonly: true, @@ -35,41 +56,26 @@ exports[`AST Fixtures legacy-fixtures types mapped-readonly AST Alignment - AST end: { column: 42, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: 'TSTypeParameter', -- const: false, - constraint: TSStringKeyword { - type: 'TSStringKeyword', ++ typeParameter: TSTypeParameter { ++ type: 'TSTypeParameter', ++ constraint: TSStringKeyword { ++ type: 'TSStringKeyword', - range: [99, 105], - loc: { - start: { column: 26, line: 3 }, - end: { column: 32, line: 3 }, - }, - }, -- in: false, -- name: Identifier { -- type: 'Identifier', -- decorators: Array [], -- name: 'P', -- optional: false, ++ range: [99, 105], ++ loc: { ++ start: { column: 26, line: 3 }, ++ end: { column: 32, line: 3 }, ++ }, ++ }, + name: 'P', - -- range: [94, 95], -- loc: { -- start: { column: 21, line: 3 }, -- end: { column: 22, line: 3 }, -- }, -- }, -- out: false, -- - range: [94, 105], - loc: { - start: { column: 21, line: 3 }, - end: { column: 32, line: 3 }, - }, - }, - ++ ++ range: [94, 105], ++ loc: { ++ start: { column: 21, line: 3 }, ++ end: { column: 32, line: 3 }, ++ }, ++ }, ++ range: [82, 117], loc: { start: { column: 9, line: 3 }, diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/1-TSESTree-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/1-TSESTree-AST.shot index d57cfcd0f424..09ca20f18bf2 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/1-TSESTree-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/1-TSESTree-AST.shot @@ -19,40 +19,28 @@ Program { type: "TSTypeAnnotation", typeAnnotation: TSMappedType { type: "TSMappedType", - nameType: null, - typeParameter: TSTypeParameter { - type: "TSTypeParameter", - const: false, - constraint: TSStringKeyword { - type: "TSStringKeyword", - - range: [90, 96], - loc: { - start: { column: 17, line: 3 }, - end: { column: 23, line: 3 }, - }, - }, - in: false, - name: Identifier { - type: "Identifier", - decorators: [], - name: "P", - optional: false, + constraint: TSStringKeyword { + type: "TSStringKeyword", - range: [85, 86], - loc: { - start: { column: 12, line: 3 }, - end: { column: 13, line: 3 }, - }, + range: [90, 96], + loc: { + start: { column: 17, line: 3 }, + end: { column: 23, line: 3 }, }, - out: false, + }, + key: Identifier { + type: "Identifier", + decorators: [], + name: "P", + optional: false, - range: [85, 96], + range: [85, 86], loc: { start: { column: 12, line: 3 }, - end: { column: 23, line: 3 }, + end: { column: 13, line: 3 }, }, }, + nameType: null, range: [82, 99], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/5-AST-Alignment-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/5-AST-Alignment-AST.shot index 5af936438b5b..7dd7abd04846 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/5-AST-Alignment-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped-untypped/snapshots/5-AST-Alignment-AST.shot @@ -23,41 +23,40 @@ exports[`AST Fixtures legacy-fixtures types mapped-untypped AST Alignment - AST type: 'TSTypeAnnotation', typeAnnotation: TSMappedType { type: 'TSMappedType', - nameType: null, - typeParameter: TSTypeParameter { - type: 'TSTypeParameter', -- const: false, - constraint: TSStringKeyword { - type: 'TSStringKeyword', +- constraint: TSStringKeyword { +- type: 'TSStringKeyword', ++ nameType: null, ++ typeParameter: TSTypeParameter { ++ type: 'TSTypeParameter', ++ constraint: TSStringKeyword { ++ type: 'TSStringKeyword', - range: [90, 96], - loc: { - start: { column: 17, line: 3 }, - end: { column: 23, line: 3 }, - }, +- range: [90, 96], +- loc: { +- start: { column: 17, line: 3 }, +- end: { column: 23, line: 3 }, ++ range: [90, 96], ++ loc: { ++ start: { column: 17, line: 3 }, ++ end: { column: 23, line: 3 }, ++ }, }, -- in: false, -- name: Identifier { -- type: 'Identifier', -- decorators: Array [], -- name: 'P', -- optional: false, -+ name: 'P', +- }, +- key: Identifier { +- type: 'Identifier', +- decorators: Array [], + name: 'P', +- optional: false, -- range: [85, 86], -- loc: { -- start: { column: 12, line: 3 }, -- end: { column: 13, line: 3 }, -- }, -- }, -- out: false, -- - range: [85, 96], +- range: [85, 86], ++ range: [85, 96], loc: { start: { column: 12, line: 3 }, - end: { column: 23, line: 3 }, +- end: { column: 13, line: 3 }, ++ end: { column: 23, line: 3 }, }, }, +- nameType: null, range: [82, 99], loc: { diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/1-TSESTree-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/1-TSESTree-AST.shot index 82119bfda8e2..98ccc34fe16a 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/1-TSESTree-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/1-TSESTree-AST.shot @@ -19,47 +19,35 @@ Program { type: "TSTypeAnnotation", typeAnnotation: TSMappedType { type: "TSMappedType", - nameType: null, - typeAnnotation: TSNumberKeyword { - type: "TSNumberKeyword", + constraint: TSStringKeyword { + type: "TSStringKeyword", - range: [99, 105], + range: [90, 96], loc: { - start: { column: 26, line: 3 }, - end: { column: 32, line: 3 }, + start: { column: 17, line: 3 }, + end: { column: 23, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: "TSTypeParameter", - const: false, - constraint: TSStringKeyword { - type: "TSStringKeyword", + key: Identifier { + type: "Identifier", + decorators: [], + name: "P", + optional: false, - range: [90, 96], - loc: { - start: { column: 17, line: 3 }, - end: { column: 23, line: 3 }, - }, - }, - in: false, - name: Identifier { - type: "Identifier", - decorators: [], - name: "P", - optional: false, - - range: [85, 86], - loc: { - start: { column: 12, line: 3 }, - end: { column: 13, line: 3 }, - }, + range: [85, 86], + loc: { + start: { column: 12, line: 3 }, + end: { column: 13, line: 3 }, }, - out: false, + }, + nameType: null, + typeAnnotation: TSNumberKeyword { + type: "TSNumberKeyword", - range: [85, 96], + range: [99, 105], loc: { - start: { column: 12, line: 3 }, - end: { column: 23, line: 3 }, + start: { column: 26, line: 3 }, + end: { column: 32, line: 3 }, }, }, diff --git a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/5-AST-Alignment-AST.shot b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/5-AST-Alignment-AST.shot index 2fcdfabe0986..62e39e79d426 100644 --- a/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/5-AST-Alignment-AST.shot +++ b/packages/ast-spec/src/legacy-fixtures/types/fixtures/mapped/snapshots/5-AST-Alignment-AST.shot @@ -23,48 +23,54 @@ exports[`AST Fixtures legacy-fixtures types mapped AST Alignment - AST 1`] = ` type: 'TSTypeAnnotation', typeAnnotation: TSMappedType { type: 'TSMappedType', - nameType: null, - typeAnnotation: TSNumberKeyword { - type: 'TSNumberKeyword', +- constraint: TSStringKeyword { +- type: 'TSStringKeyword', ++ nameType: null, ++ typeAnnotation: TSNumberKeyword { ++ type: 'TSNumberKeyword', - range: [99, 105], +- range: [90, 96], ++ range: [99, 105], loc: { - start: { column: 26, line: 3 }, - end: { column: 32, line: 3 }, +- start: { column: 17, line: 3 }, +- end: { column: 23, line: 3 }, ++ start: { column: 26, line: 3 }, ++ end: { column: 32, line: 3 }, }, }, - typeParameter: TSTypeParameter { - type: 'TSTypeParameter', -- const: false, - constraint: TSStringKeyword { - type: 'TSStringKeyword', +- key: Identifier { +- type: 'Identifier', +- decorators: Array [], ++ typeParameter: TSTypeParameter { ++ type: 'TSTypeParameter', ++ constraint: TSStringKeyword { ++ type: 'TSStringKeyword', ++ ++ range: [90, 96], ++ loc: { ++ start: { column: 17, line: 3 }, ++ end: { column: 23, line: 3 }, ++ }, ++ }, + name: 'P', +- optional: false, - range: [90, 96], - loc: { - start: { column: 17, line: 3 }, - end: { column: 23, line: 3 }, - }, - }, -- in: false, -- name: Identifier { -- type: 'Identifier', -- decorators: Array [], -- name: 'P', -- optional: false, -+ name: 'P', - -- range: [85, 86], -- loc: { -- start: { column: 12, line: 3 }, -- end: { column: 13, line: 3 }, -- }, -- }, -- out: false, -- - range: [85, 96], +- range: [85, 86], ++ range: [85, 96], loc: { start: { column: 12, line: 3 }, - end: { column: 23, line: 3 }, +- end: { column: 13, line: 3 }, +- }, +- }, +- nameType: null, +- typeAnnotation: TSNumberKeyword { +- type: 'TSNumberKeyword', +- +- range: [99, 105], +- loc: { +- start: { column: 26, line: 3 }, +- end: { column: 32, line: 3 }, ++ end: { column: 23, line: 3 }, }, }, diff --git a/packages/ast-spec/src/type/TSMappedType/spec.ts b/packages/ast-spec/src/type/TSMappedType/spec.ts index 8b81c4f77bb6..44f64ac8621a 100644 --- a/packages/ast-spec/src/type/TSMappedType/spec.ts +++ b/packages/ast-spec/src/type/TSMappedType/spec.ts @@ -1,11 +1,17 @@ import type { AST_NODE_TYPES } from '../../ast-node-types'; import type { BaseNode } from '../../base/BaseNode'; +import type { Identifier } from '../../expression/Identifier/spec'; import type { TSTypeParameter } from '../../special/TSTypeParameter/spec'; import type { TypeNode } from '../../unions/TypeNode'; export interface TSMappedType extends BaseNode { type: AST_NODE_TYPES.TSMappedType; + + /** @deprecated Use {@link `constraint`} and {@link `key`} instead. */ typeParameter: TSTypeParameter; + + constraint: TypeNode; + key: Identifier; readonly: boolean | '-' | '+' | undefined; optional: boolean | '-' | '+' | undefined; typeAnnotation: TypeNode | undefined; diff --git a/packages/typescript-estree/src/convert.ts b/packages/typescript-estree/src/convert.ts index 62e27929d8d1..99eef7551032 100644 --- a/packages/typescript-estree/src/convert.ts +++ b/packages/typescript-estree/src/convert.ts @@ -2532,20 +2532,29 @@ export class Converter { ); } - return this.createNode(node, { - type: AST_NODE_TYPES.TSMappedType, - nameType: this.convertChild(node.nameType) ?? null, - optional: - node.questionToken && - (node.questionToken.kind === SyntaxKind.QuestionToken || - getTextForTokenKind(node.questionToken.kind)), - readonly: - node.readonlyToken && - (node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword || - getTextForTokenKind(node.readonlyToken.kind)), - typeAnnotation: node.type && this.convertChild(node.type), - typeParameter: this.convertChild(node.typeParameter), - }); + return this.createNode( + node, + this.#withDeprecatedGetter( + { + type: AST_NODE_TYPES.TSMappedType, + nameType: this.convertChild(node.nameType) ?? null, + optional: + node.questionToken && + (node.questionToken.kind === SyntaxKind.QuestionToken || + getTextForTokenKind(node.questionToken.kind)), + readonly: + node.readonlyToken && + (node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword || + getTextForTokenKind(node.readonlyToken.kind)), + typeAnnotation: node.type && this.convertChild(node.type), + constraint: this.convertChild(node.typeParameter.constraint), + key: this.convertChild(node.typeParameter.name), + }, + 'typeParameter', + this.convertChild(node.typeParameter), + "'constraint' and 'key'", + ), + ); } case SyntaxKind.ParenthesizedExpression: @@ -3360,6 +3369,52 @@ export class Converter { return node as Properties & Record; } + /** + * Creates a getter for a property under key, returning the value. + * If suppressDeprecatedPropertyWarnings is not enabled, the + * getter also console warns about the deprecation. + * + * @see https://github.com/typescript-eslint/typescript-eslint/issues/6469 + */ + #withDeprecatedGetter< + Properties extends { type: string }, + Key extends string, + Value, + >( + node: Properties, + key: Key, + value: Value, + instead: string, + ): Properties & Record { + let warned = false; + + Object.defineProperty(node, key, { + configurable: true, + get: this.options.suppressDeprecatedPropertyWarnings + ? (): Value => value + : (): Value => { + if (!warned) { + process.emitWarning( + `The '${key}' property is deprecated on ${node.type} nodes. Use ${instead} instead. See https://typescript-eslint.io/linting/troubleshooting#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, + 'DeprecationWarning', + ); + warned = true; + } + + return value; + }, + set(newValue): void { + Object.defineProperty(node, key, { + enumerable: true, + writable: true, + value: newValue, + }); + }, + }); + + return node as Properties & Record; + } + #throwError(node: ts.Node | number, message: string): asserts node is never { let start; let end; diff --git a/packages/typescript-estree/tests/lib/convert.test.ts b/packages/typescript-estree/tests/lib/convert.test.ts index 3e7991683e85..fa2b9f5e0930 100644 --- a/packages/typescript-estree/tests/lib/convert.test.ts +++ b/packages/typescript-estree/tests/lib/convert.test.ts @@ -289,7 +289,29 @@ describe('convert', () => { return maps.tsNodeToESTreeNodeMap.get(tsCallExpression); }; - it('warns on a deprecated property access when suppressDeprecatedPropertyWarnings is false', () => { + const getTsMappedType = ( + converterOptions?: ConverterOptions, + ): TSESTree.TSMappedType => { + const ast = convertCode(` + type MappedType = { + [Key in Type]: Value; + }; + `); + const tsMappedType = (ast.statements[0] as ts.TypeAliasDeclaration) + .type as ts.MappedTypeNode; + const instance = new Converter(ast, { + shouldPreserveNodeMaps: true, + ...converterOptions, + }); + + instance.convertProgram(); + + const maps = instance.getASTMaps(); + + return maps.tsNodeToESTreeNodeMap.get(tsMappedType); + }; + + it('warns on a deprecated aliased property access when suppressDeprecatedPropertyWarnings is false', () => { const emitWarning = jest .spyOn(process, 'emitWarning') .mockImplementation(); @@ -306,7 +328,7 @@ describe('convert', () => { ); }); - it('does not warn on a subsequent deprecated property access when suppressDeprecatedPropertyWarnings is false', () => { + it('does not warn on a subsequent deprecated aliased property access when suppressDeprecatedPropertyWarnings is false', () => { const emitWarning = jest .spyOn(process, 'emitWarning') .mockImplementation(); @@ -322,7 +344,7 @@ describe('convert', () => { expect(emitWarning).toHaveBeenCalledTimes(1); }); - it('does not warn on a deprecated property access when suppressDeprecatedPropertyWarnings is true', () => { + it('does not warn on a deprecated aliased property access when suppressDeprecatedPropertyWarnings is true', () => { const emitWarning = jest .spyOn(process, 'emitWarning') .mockImplementation(); @@ -336,13 +358,13 @@ describe('convert', () => { expect(emitWarning).not.toHaveBeenCalled(); }); - it('does not allow enumeration of deprecated properties', () => { + it('does not allow enumeration of deprecated aliased properties', () => { const esCallExpression = getEsCallExpression(); expect(Object.keys(esCallExpression)).not.toContain('typeParameters'); }); - it('allows writing to the deprecated property as a new enumerable value', () => { + it('allows writing to the deprecated aliased property as a new enumerable value', () => { const esCallExpression = getEsCallExpression(); // eslint-disable-next-line deprecation/deprecation @@ -352,5 +374,69 @@ describe('convert', () => { expect(esCallExpression.typeParameters).toBeUndefined(); expect(Object.keys(esCallExpression)).toContain('typeParameters'); }); + + it('warns on a deprecated getter property access when suppressDeprecatedPropertyWarnings is false', () => { + const emitWarning = jest + .spyOn(process, 'emitWarning') + .mockImplementation(); + const tsMappedType = getTsMappedType({ + suppressDeprecatedPropertyWarnings: false, + }); + + // eslint-disable-next-line deprecation/deprecation + tsMappedType.typeParameter; + + expect(emitWarning).toHaveBeenCalledWith( + `The 'typeParameter' property is deprecated on TSMappedType nodes. Use 'constraint' and 'key' instead. See https://typescript-eslint.io/linting/troubleshooting#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, + 'DeprecationWarning', + ); + }); + + it('does not warn on a subsequent deprecated getter property access when suppressDeprecatedPropertyWarnings is false', () => { + const emitWarning = jest + .spyOn(process, 'emitWarning') + .mockImplementation(); + const tsMappedType = getTsMappedType({ + suppressDeprecatedPropertyWarnings: false, + }); + + /* eslint-disable deprecation/deprecation */ + tsMappedType.typeParameter; + tsMappedType.typeParameter; + /* eslint-enable deprecation/deprecation */ + + expect(emitWarning).toHaveBeenCalledTimes(1); + }); + + it('does not warn on a deprecated getter property access when suppressDeprecatedPropertyWarnings is true', () => { + const emitWarning = jest + .spyOn(process, 'emitWarning') + .mockImplementation(); + const tsMappedType = getTsMappedType({ + suppressDeprecatedPropertyWarnings: true, + }); + + // eslint-disable-next-line deprecation/deprecation + tsMappedType.typeParameter; + + expect(emitWarning).not.toHaveBeenCalled(); + }); + + it('does not allow enumeration of deprecated getter properties', () => { + const tsMappedType = getTsMappedType(); + + expect(Object.keys(tsMappedType)).not.toContain('typeParameter'); + }); + + it('allows writing to the deprecated getter property as a new enumerable value', () => { + const tsMappedType = getTsMappedType(); + + // eslint-disable-next-line deprecation/deprecation + tsMappedType.typeParameter = undefined!; + + // eslint-disable-next-line deprecation/deprecation + expect(tsMappedType.typeParameter).toBeUndefined(); + expect(Object.keys(tsMappedType)).toContain('typeParameter'); + }); }); }); From bd4af4e39bad56cdfa897d4663d184b98a843394 Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Thu, 25 May 2023 17:56:15 +0300 Subject: [PATCH 2/9] Aha, refactor to deduplicate - and fix property references --- packages/eslint-plugin/src/rules/indent.ts | 6 ++-- .../src/util/collectUnusedVariables.ts | 2 +- packages/typescript-estree/src/convert.ts | 33 ++++--------------- packages/visitor-keys/src/visitor-keys.ts | 2 +- 4 files changed, 10 insertions(+), 33 deletions(-) diff --git a/packages/eslint-plugin/src/rules/indent.ts b/packages/eslint-plugin/src/rules/indent.ts index 80d81293dd09..d849cd1a950c 100644 --- a/packages/eslint-plugin/src/rules/indent.ts +++ b/packages/eslint-plugin/src/rules/indent.ts @@ -376,9 +376,7 @@ export default util.createRule({ TSMappedType(node: TSESTree.TSMappedType) { const sourceCode = context.getSourceCode(); - const squareBracketStart = sourceCode.getTokenBefore( - node.typeParameter, - )!; + const squareBracketStart = sourceCode.getTokenBefore(node.key)!; // transform it to an ObjectExpression return rules['ObjectExpression, ObjectPattern']({ @@ -387,7 +385,7 @@ export default util.createRule({ { parent: node, type: AST_NODE_TYPES.Property, - key: node.typeParameter as any, + key: node.key as any, value: node.typeAnnotation as any, // location data diff --git a/packages/eslint-plugin/src/util/collectUnusedVariables.ts b/packages/eslint-plugin/src/util/collectUnusedVariables.ts index a0ad2676a01b..da879fcc55bd 100644 --- a/packages/eslint-plugin/src/util/collectUnusedVariables.ts +++ b/packages/eslint-plugin/src/util/collectUnusedVariables.ts @@ -312,7 +312,7 @@ class UnusedVarsVisitor< protected TSMappedType(node: TSESTree.TSMappedType): void { // mapped types create a variable for their type name, but it's not necessary to reference it, // so we shouldn't consider it as unused for the purpose of this rule. - this.markVariableAsUsed(node.typeParameter.name); + this.markVariableAsUsed(node.key); } protected TSMethodSignature = this.visitFunctionTypeSignature; diff --git a/packages/typescript-estree/src/convert.ts b/packages/typescript-estree/src/convert.ts index 99eef7551032..cb83b75aba95 100644 --- a/packages/typescript-estree/src/convert.ts +++ b/packages/typescript-estree/src/convert.ts @@ -3340,33 +3340,12 @@ export class Converter { aliasKey: AliasKey, valueKey: ValueKey, ): Properties & Record { - let warned = false; - - Object.defineProperty(node, aliasKey, { - configurable: true, - get: this.options.suppressDeprecatedPropertyWarnings - ? (): Properties[typeof valueKey] => node[valueKey] - : (): Properties[typeof valueKey] => { - if (!warned) { - process.emitWarning( - `The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://typescript-eslint.io/linting/troubleshooting#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, - 'DeprecationWarning', - ); - warned = true; - } - - return node[valueKey]; - }, - set(value): void { - Object.defineProperty(node, aliasKey, { - enumerable: true, - writable: true, - value, - }); - }, - }); - - return node as Properties & Record; + return this.#withDeprecatedGetter( + node, + aliasKey, + node[valueKey], + `'${valueKey}'`, + ); } /** diff --git a/packages/visitor-keys/src/visitor-keys.ts b/packages/visitor-keys/src/visitor-keys.ts index d6b264350008..22fe1352e3a2 100644 --- a/packages/visitor-keys/src/visitor-keys.ts +++ b/packages/visitor-keys/src/visitor-keys.ts @@ -212,7 +212,7 @@ const additionalKeys: AdditionalKeys = { TSIntersectionType: ['types'], TSIntrinsicKeyword: [], TSLiteralType: ['literal'], - TSMappedType: ['nameType', 'typeParameter', 'typeAnnotation'], + TSMappedType: ['constraint', 'key', 'nameType', 'typeAnnotation'], TSMethodSignature: ['typeParameters', 'key', 'params', 'returnType'], TSModuleBlock: ['body'], TSModuleDeclaration: ['id', 'body'], From ce59f894615d952a47c5666003b63818bbe7f30d Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Thu, 25 May 2023 20:52:52 +0300 Subject: [PATCH 3/9] Updated scope-manager snapshots --- .../type-declaration/mapped-named.ts.shot | 71 ++++++++----------- .../fixtures/type-declaration/mapped.ts.shot | 54 ++++++-------- 2 files changed, 52 insertions(+), 73 deletions(-) diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot index c5e5927384fc..478e8835a323 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot @@ -13,7 +13,7 @@ ScopeManager { ], name: "T", references: [ - Reference$4 { + Reference$5 { identifier: Identifier<"T">, isRead: true, isTypeReference: true, @@ -37,39 +37,10 @@ ScopeManager { isValueVariable: false, isTypeVariable: true, }, - Variable$4 { - defs: [ - TypeDefinition$3 { - name: Identifier<"k">, - node: TSTypeParameter$3, - }, - ], - name: "k", - references: [ - Reference$2 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: Variable$4, - }, - Reference$3 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: Variable$4, - }, - ], - isValueVariable: false, - isTypeVariable: true, - }, ], scopes: [ GlobalScope$1 { - block: Program$4, + block: Program$3, isStrict: false, references: [ Reference$1 { @@ -95,21 +66,39 @@ ScopeManager { ], }, MappedTypeScope$2 { - block: TSMappedType$5, + block: TSMappedType$4, isStrict: true, references: [ - Reference$2, - Reference$3, - Reference$4, + Reference$2 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: null, + }, + Reference$3 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: null, + }, + Reference$4 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: null, + }, + Reference$5, ], - set: Map { - "k" => Variable$4, - }, + set: Map {}, type: "mappedType", upper: GlobalScope$1, - variables: [ - Variable$4, - ], + variables: [], }, ], } diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot index 6790ca3dd92c..f6279b887a94 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot @@ -13,7 +13,7 @@ ScopeManager { ], name: "T", references: [ - Reference$3 { + Reference$4 { identifier: Identifier<"T">, isRead: true, isTypeReference: true, @@ -37,31 +37,10 @@ ScopeManager { isValueVariable: false, isTypeVariable: true, }, - Variable$4 { - defs: [ - TypeDefinition$3 { - name: Identifier<"k">, - node: TSTypeParameter$3, - }, - ], - name: "k", - references: [ - Reference$2 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: Variable$4, - }, - ], - isValueVariable: false, - isTypeVariable: true, - }, ], scopes: [ GlobalScope$1 { - block: Program$4, + block: Program$3, isStrict: false, references: [ Reference$1 { @@ -87,20 +66,31 @@ ScopeManager { ], }, MappedTypeScope$2 { - block: TSMappedType$5, + block: TSMappedType$4, isStrict: true, references: [ - Reference$2, - Reference$3, + Reference$2 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: null, + }, + Reference$3 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: null, + }, + Reference$4, ], - set: Map { - "k" => Variable$4, - }, + set: Map {}, type: "mappedType", upper: GlobalScope$1, - variables: [ - Variable$4, - ], + variables: [], }, ], } From 7621e7f631efa7bff9aea4e6eabeb844525ca941 Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Thu, 6 Jul 2023 15:54:27 -0400 Subject: [PATCH 4/9] Fixed snapshots, though not the bug --- .../src/referencer/TypeVisitor.ts | 6 ++ .../mapped-named-literal-no-references.ts | 2 + ...mapped-named-literal-no-references.ts.shot | 83 +++++++++++++++++++ .../mapped-named-literal-referenced.ts | 2 + .../mapped-named-literal-referenced.ts.shot | 82 ++++++++++++++++++ .../type-declaration/mapped-named.ts.shot | 4 +- packages/visitor-keys/src/visitor-keys.ts | 2 +- 7 files changed, 179 insertions(+), 2 deletions(-) create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot diff --git a/packages/scope-manager/src/referencer/TypeVisitor.ts b/packages/scope-manager/src/referencer/TypeVisitor.ts index 9daa2e64093a..0a874b363788 100644 --- a/packages/scope-manager/src/referencer/TypeVisitor.ts +++ b/packages/scope-manager/src/referencer/TypeVisitor.ts @@ -197,7 +197,13 @@ class TypeVisitor extends Visitor { protected TSMappedType(node: TSESTree.TSMappedType): void { // mapped types key can only be referenced within their return value this.#referencer.scopeManager.nestMappedTypeScope(node); + // So now we'll need to update our visitor so that we declare the key as a type variable, then visit the constraint, then the name type, then the type annotation. + // this.visit(node.key); + // this.visit(node.constraint); + // this.visit(node.nameType); + // this.visit(node.typeAnnotation); this.visitChildren(node); + this.#referencer.close(node); } diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts new file mode 100644 index 000000000000..3ae8ec6a9176 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts @@ -0,0 +1,2 @@ +type T = 1; +type M = { [T in string as T]: 1 }; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot new file mode 100644 index 000000000000..adb7db40f707 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot @@ -0,0 +1,83 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-declaration mapped-named-literal-no-references 1`] = ` +ScopeManager { + variables: [ + ImplicitGlobalConstTypeVariable, + Variable$2 { + defs: [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: [ + Reference$1 { + identifier: Identifier<"T">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$2, + }, + Reference$2 { + identifier: Identifier<"T">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$2, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$3 { + defs: [ + TypeDefinition$2 { + name: Identifier<"M">, + node: TSTypeAliasDeclaration$2, + }, + ], + name: "M", + references: [], + isValueVariable: false, + isTypeVariable: true, + }, + ], + scopes: [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: [], + set: Map { + "const" => ImplicitGlobalConstTypeVariable, + "T" => Variable$2, + "M" => Variable$3, + }, + type: "global", + upper: null, + variables: [ + ImplicitGlobalConstTypeVariable, + Variable$2, + Variable$3, + ], + }, + MappedTypeScope$2 { + block: TSMappedType$4, + isStrict: true, + references: [ + Reference$1, + Reference$2, + ], + set: Map { + "k" => Variable$4, + }, + type: "mappedType", + upper: GlobalScope$1, + variables: [], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts new file mode 100644 index 000000000000..a7b4c95de066 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts @@ -0,0 +1,2 @@ +type T = 1; // should have 1 reference +type M = { [K in string as T]: 1 }; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot new file mode 100644 index 000000000000..854740a7bbec --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot @@ -0,0 +1,82 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-declaration mapped-named-literal-referenced 1`] = ` +ScopeManager { + variables: [ + ImplicitGlobalConstTypeVariable, + Variable$2 { + defs: [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: [ + Reference$2 { + identifier: Identifier<"T">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$2, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$3 { + defs: [ + TypeDefinition$2 { + name: Identifier<"M">, + node: TSTypeAliasDeclaration$2, + }, + ], + name: "M", + references: [], + isValueVariable: false, + isTypeVariable: true, + }, + ], + scopes: [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: [], + set: Map { + "const" => ImplicitGlobalConstTypeVariable, + "T" => Variable$2, + "M" => Variable$3, + }, + type: "global", + upper: null, + variables: [ + ImplicitGlobalConstTypeVariable, + Variable$2, + Variable$3, + ], + }, + MappedTypeScope$2 { + block: TSMappedType$4, + isStrict: true, + references: [ + Reference$1 { + identifier: Identifier<"K">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: null, + }, + Reference$2, + ], + set: Map { + "k" => Variable$4, + }, + type: "mappedType", + upper: GlobalScope$1, + variables: [], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot index 478e8835a323..3bfb417014c1 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot @@ -95,7 +95,9 @@ ScopeManager { }, Reference$5, ], - set: Map {}, + set: Map { + "k" => Variable$4, + }, type: "mappedType", upper: GlobalScope$1, variables: [], diff --git a/packages/visitor-keys/src/visitor-keys.ts b/packages/visitor-keys/src/visitor-keys.ts index 22fe1352e3a2..5b00ee4beda4 100644 --- a/packages/visitor-keys/src/visitor-keys.ts +++ b/packages/visitor-keys/src/visitor-keys.ts @@ -212,7 +212,7 @@ const additionalKeys: AdditionalKeys = { TSIntersectionType: ['types'], TSIntrinsicKeyword: [], TSLiteralType: ['literal'], - TSMappedType: ['constraint', 'key', 'nameType', 'typeAnnotation'], + TSMappedType: ['key', 'constraint', 'nameType', 'typeAnnotation'], TSMethodSignature: ['typeParameters', 'key', 'params', 'returnType'], TSModuleBlock: ['body'], TSModuleDeclaration: ['id', 'body'], From 3b27d7fb51237383b160c895118cfef9c9860c61 Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Thu, 6 Jul 2023 15:55:28 -0400 Subject: [PATCH 5/9] Remove comment, oops --- packages/scope-manager/src/referencer/TypeVisitor.ts | 5 ----- 1 file changed, 5 deletions(-) diff --git a/packages/scope-manager/src/referencer/TypeVisitor.ts b/packages/scope-manager/src/referencer/TypeVisitor.ts index 0a874b363788..ac950c3acf41 100644 --- a/packages/scope-manager/src/referencer/TypeVisitor.ts +++ b/packages/scope-manager/src/referencer/TypeVisitor.ts @@ -197,11 +197,6 @@ class TypeVisitor extends Visitor { protected TSMappedType(node: TSESTree.TSMappedType): void { // mapped types key can only be referenced within their return value this.#referencer.scopeManager.nestMappedTypeScope(node); - // So now we'll need to update our visitor so that we declare the key as a type variable, then visit the constraint, then the name type, then the type annotation. - // this.visit(node.key); - // this.visit(node.constraint); - // this.visit(node.nameType); - // this.visit(node.typeAnnotation); this.visitChildren(node); this.#referencer.close(node); From 933e00a2453fe257e46a9cd42c4bf38cce559fe7 Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Fri, 7 Jul 2023 11:56:56 -0400 Subject: [PATCH 6/9] Switch TSMappedType type visiting to be more manual --- .../src/referencer/TypeVisitor.ts | 17 ++++- ...mapped-named-literal-no-references.ts.shot | 46 +++++++------- .../mapped-named-literal-referenced.ts.shot | 29 +++++---- .../type-declaration/mapped-named.ts.shot | 62 +++++++++++-------- .../fixtures/type-declaration/mapped.ts.shot | 49 +++++++++------ 5 files changed, 121 insertions(+), 82 deletions(-) diff --git a/packages/scope-manager/src/referencer/TypeVisitor.ts b/packages/scope-manager/src/referencer/TypeVisitor.ts index ac950c3acf41..3c990a8e3da5 100644 --- a/packages/scope-manager/src/referencer/TypeVisitor.ts +++ b/packages/scope-manager/src/referencer/TypeVisitor.ts @@ -197,8 +197,21 @@ class TypeVisitor extends Visitor { protected TSMappedType(node: TSESTree.TSMappedType): void { // mapped types key can only be referenced within their return value this.#referencer.scopeManager.nestMappedTypeScope(node); - this.visitChildren(node); - + this.#referencer + .currentScope() + .defineIdentifier( + node.key, + new TypeDefinition( + node.key, + node.parent as + | TSESTree.TSInterfaceDeclaration + | TSESTree.TSTypeAliasDeclaration + | TSESTree.TSTypeParameter, + ), + ); + this.visit(node.constraint); + this.visit(node.nameType); + this.visit(node.typeAnnotation); this.#referencer.close(node); } diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot index adb7db40f707..38a5ed50290e 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot @@ -12,24 +12,7 @@ ScopeManager { }, ], name: "T", - references: [ - Reference$1 { - identifier: Identifier<"T">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: Variable$2, - }, - Reference$2 { - identifier: Identifier<"T">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: Variable$2, - }, - ], + references: [], isValueVariable: false, isTypeVariable: true, }, @@ -45,6 +28,26 @@ ScopeManager { isValueVariable: false, isTypeVariable: true, }, + Variable$4 { + defs: [ + TypeDefinition$3 { + name: Identifier<"T">, + }, + ], + name: "T", + references: [ + Reference$1 { + identifier: Identifier<"T">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$4, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, ], scopes: [ GlobalScope$1 { @@ -69,14 +72,15 @@ ScopeManager { isStrict: true, references: [ Reference$1, - Reference$2, ], set: Map { - "k" => Variable$4, + "T" => Variable$4, }, type: "mappedType", upper: GlobalScope$1, - variables: [], + variables: [ + Variable$4, + ], }, ], } diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot index 854740a7bbec..441bba4f2521 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot @@ -13,7 +13,7 @@ ScopeManager { ], name: "T", references: [ - Reference$2 { + Reference$1 { identifier: Identifier<"T">, isRead: true, isTypeReference: true, @@ -37,6 +37,17 @@ ScopeManager { isValueVariable: false, isTypeVariable: true, }, + Variable$4 { + defs: [ + TypeDefinition$3 { + name: Identifier<"K">, + }, + ], + name: "K", + references: [], + isValueVariable: false, + isTypeVariable: true, + }, ], scopes: [ GlobalScope$1 { @@ -60,22 +71,16 @@ ScopeManager { block: TSMappedType$4, isStrict: true, references: [ - Reference$1 { - identifier: Identifier<"K">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: null, - }, - Reference$2, + Reference$1, ], set: Map { - "k" => Variable$4, + "K" => Variable$4, }, type: "mappedType", upper: GlobalScope$1, - variables: [], + variables: [ + Variable$4, + ], }, ], } diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot index 3bfb417014c1..88f6e30feb8d 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot @@ -13,7 +13,7 @@ ScopeManager { ], name: "T", references: [ - Reference$5 { + Reference$4 { identifier: Identifier<"T">, isRead: true, isTypeReference: true, @@ -37,6 +37,34 @@ ScopeManager { isValueVariable: false, isTypeVariable: true, }, + Variable$4 { + defs: [ + TypeDefinition$3 { + name: Identifier<"k">, + }, + ], + name: "k", + references: [ + Reference$2 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$4, + }, + Reference$3 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$4, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, ], scopes: [ GlobalScope$1 { @@ -69,38 +97,18 @@ ScopeManager { block: TSMappedType$4, isStrict: true, references: [ - Reference$2 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: null, - }, - Reference$3 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: null, - }, - Reference$4 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: null, - }, - Reference$5, + Reference$2, + Reference$3, + Reference$4, ], set: Map { "k" => Variable$4, }, type: "mappedType", upper: GlobalScope$1, - variables: [], + variables: [ + Variable$4, + ], }, ], } diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot index f6279b887a94..f61147d9e1aa 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot @@ -13,7 +13,7 @@ ScopeManager { ], name: "T", references: [ - Reference$4 { + Reference$3 { identifier: Identifier<"T">, isRead: true, isTypeReference: true, @@ -37,6 +37,26 @@ ScopeManager { isValueVariable: false, isTypeVariable: true, }, + Variable$4 { + defs: [ + TypeDefinition$3 { + name: Identifier<"k">, + }, + ], + name: "k", + references: [ + Reference$2 { + identifier: Identifier<"k">, + isRead: true, + isTypeReference: true, + isValueReference: false, + isWrite: false, + resolved: Variable$4, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, ], scopes: [ GlobalScope$1 { @@ -69,28 +89,17 @@ ScopeManager { block: TSMappedType$4, isStrict: true, references: [ - Reference$2 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: null, - }, - Reference$3 { - identifier: Identifier<"k">, - isRead: true, - isTypeReference: true, - isValueReference: false, - isWrite: false, - resolved: null, - }, - Reference$4, + Reference$2, + Reference$3, ], - set: Map {}, + set: Map { + "k" => Variable$4, + }, type: "mappedType", upper: GlobalScope$1, - variables: [], + variables: [ + Variable$4, + ], }, ], } From 210e2810f6e83be0f3b565cb16bf476a05d945dd Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Sun, 14 Apr 2024 18:55:52 -0400 Subject: [PATCH 7/9] Lint fixes --- packages/eslint-plugin/src/rules/indent.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/packages/eslint-plugin/src/rules/indent.ts b/packages/eslint-plugin/src/rules/indent.ts index 9ebb23d75844..b1da3a6cf74c 100644 --- a/packages/eslint-plugin/src/rules/indent.ts +++ b/packages/eslint-plugin/src/rules/indent.ts @@ -382,6 +382,7 @@ export default createRule({ TSMappedType(node: TSESTree.TSMappedType) { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion const squareBracketStart = context.sourceCode.getTokenBefore( + // eslint-disable-next-line deprecation/deprecation node.typeParameter, )!; @@ -392,6 +393,7 @@ export default createRule({ { parent: node, type: AST_NODE_TYPES.Property, + // eslint-disable-next-line deprecation/deprecation key: node.typeParameter as any, value: node.typeAnnotation as any, From 218036c324d6c5d64bc4ab311b46291678c2cfd9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Josh=20Goldberg=20=E2=9C=A8?= Date: Mon, 15 Apr 2024 11:45:56 -0400 Subject: [PATCH 8/9] Update packages/scope-manager/src/referencer/TypeVisitor.ts Co-authored-by: Brad Zacher --- packages/scope-manager/src/referencer/TypeVisitor.ts | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/packages/scope-manager/src/referencer/TypeVisitor.ts b/packages/scope-manager/src/referencer/TypeVisitor.ts index f6dc40b1a8a9..fc8de267d61d 100644 --- a/packages/scope-manager/src/referencer/TypeVisitor.ts +++ b/packages/scope-manager/src/referencer/TypeVisitor.ts @@ -205,10 +205,7 @@ class TypeVisitor extends Visitor { node.key, new TypeDefinition( node.key, - node.parent as - | TSESTree.TSInterfaceDeclaration - | TSESTree.TSTypeAliasDeclaration - | TSESTree.TSTypeParameter, + node, ), ); this.visit(node.constraint); From d557e45b15e052a7e6016433df7a1580964ebea0 Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Mon, 15 Apr 2024 11:51:01 -0400 Subject: [PATCH 9/9] Avoided node.parent as directed --- packages/scope-manager/src/definition/TypeDefinition.ts | 1 + packages/scope-manager/src/referencer/TypeVisitor.ts | 8 +------- .../mapped-named-literal-no-references.ts.shot | 5 +++-- .../mapped-named-literal-referenced.ts.shot | 5 +++-- .../tests/fixtures/type-declaration/mapped-named.ts.shot | 5 +++-- .../tests/fixtures/type-declaration/mapped.ts.shot | 5 +++-- 6 files changed, 14 insertions(+), 15 deletions(-) diff --git a/packages/scope-manager/src/definition/TypeDefinition.ts b/packages/scope-manager/src/definition/TypeDefinition.ts index 506274d42734..75de333bb0ad 100644 --- a/packages/scope-manager/src/definition/TypeDefinition.ts +++ b/packages/scope-manager/src/definition/TypeDefinition.ts @@ -6,6 +6,7 @@ import { DefinitionType } from './DefinitionType'; class TypeDefinition extends DefinitionBase< DefinitionType.Type, | TSESTree.TSInterfaceDeclaration + | TSESTree.TSMappedType | TSESTree.TSTypeAliasDeclaration | TSESTree.TSTypeParameter, null, diff --git a/packages/scope-manager/src/referencer/TypeVisitor.ts b/packages/scope-manager/src/referencer/TypeVisitor.ts index fc8de267d61d..ab3b8a0b1bf4 100644 --- a/packages/scope-manager/src/referencer/TypeVisitor.ts +++ b/packages/scope-manager/src/referencer/TypeVisitor.ts @@ -201,13 +201,7 @@ class TypeVisitor extends Visitor { this.#referencer.scopeManager.nestMappedTypeScope(node); this.#referencer .currentScope() - .defineIdentifier( - node.key, - new TypeDefinition( - node.key, - node, - ), - ); + .defineIdentifier(node.key, new TypeDefinition(node.key, node)); this.visit(node.constraint); this.visit(node.nameType); this.visit(node.typeAnnotation); diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot index 38a5ed50290e..cbb18cc721b7 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-no-references.ts.shot @@ -32,6 +32,7 @@ ScopeManager { defs: [ TypeDefinition$3 { name: Identifier<"T">, + node: TSMappedType$3, }, ], name: "T", @@ -51,7 +52,7 @@ ScopeManager { ], scopes: [ GlobalScope$1 { - block: Program$3, + block: Program$4, isStrict: false, references: [], set: Map { @@ -68,7 +69,7 @@ ScopeManager { ], }, MappedTypeScope$2 { - block: TSMappedType$4, + block: TSMappedType$3, isStrict: true, references: [ Reference$1, diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot index 441bba4f2521..c1b6bd45a180 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named-literal-referenced.ts.shot @@ -41,6 +41,7 @@ ScopeManager { defs: [ TypeDefinition$3 { name: Identifier<"K">, + node: TSMappedType$3, }, ], name: "K", @@ -51,7 +52,7 @@ ScopeManager { ], scopes: [ GlobalScope$1 { - block: Program$3, + block: Program$4, isStrict: false, references: [], set: Map { @@ -68,7 +69,7 @@ ScopeManager { ], }, MappedTypeScope$2 { - block: TSMappedType$4, + block: TSMappedType$3, isStrict: true, references: [ Reference$1, diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot index 88f6e30feb8d..11aa7739cb76 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped-named.ts.shot @@ -41,6 +41,7 @@ ScopeManager { defs: [ TypeDefinition$3 { name: Identifier<"k">, + node: TSMappedType$3, }, ], name: "k", @@ -68,7 +69,7 @@ ScopeManager { ], scopes: [ GlobalScope$1 { - block: Program$3, + block: Program$4, isStrict: false, references: [ Reference$1 { @@ -94,7 +95,7 @@ ScopeManager { ], }, MappedTypeScope$2 { - block: TSMappedType$4, + block: TSMappedType$3, isStrict: true, references: [ Reference$2, diff --git a/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot index f61147d9e1aa..59aab2c5e1de 100644 --- a/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot +++ b/packages/scope-manager/tests/fixtures/type-declaration/mapped.ts.shot @@ -41,6 +41,7 @@ ScopeManager { defs: [ TypeDefinition$3 { name: Identifier<"k">, + node: TSMappedType$3, }, ], name: "k", @@ -60,7 +61,7 @@ ScopeManager { ], scopes: [ GlobalScope$1 { - block: Program$3, + block: Program$4, isStrict: false, references: [ Reference$1 { @@ -86,7 +87,7 @@ ScopeManager { ], }, MappedTypeScope$2 { - block: TSMappedType$4, + block: TSMappedType$3, isStrict: true, references: [ Reference$2,