From 6bf7a89aa0344f2b5b1a75eedbed80bba79a5835 Mon Sep 17 00:00:00 2001 From: Brad Zacher Date: Wed, 6 May 2020 01:42:47 -0700 Subject: [PATCH] feat: visit type annotations --- .../src/referencer/PatternVisitor.ts | 8 +- .../src/referencer/Referencer.ts | 21 ++-- .../parameter-array-destructure.ts | 2 + .../parameter-array-destructure.ts.shot | 91 ++++++++++++++++ .../type-annotation/parameter-default.ts | 2 + .../type-annotation/parameter-default.ts.shot | 100 ++++++++++++++++++ .../parameter-object-destructure.ts | 2 + .../parameter-object-destructure.ts.shot | 91 ++++++++++++++++ .../type-annotation/parameter-rest.ts | 2 + .../type-annotation/parameter-rest.ts.shot | 91 ++++++++++++++++ .../fixtures/type-annotation/parameter.ts | 2 + .../type-annotation/parameter.ts.shot | 97 +++++++++++++++++ .../variable-array-destructure.ts | 2 + .../variable-array-destructure.ts.shot | 66 ++++++++++++ .../type-annotation/variable-const.ts | 2 + .../type-annotation/variable-const.ts.shot | 72 +++++++++++++ .../fixtures/type-annotation/variable-let.ts | 2 + .../type-annotation/variable-let.ts.shot | 63 +++++++++++ .../variable-object-destructure.ts | 2 + .../variable-object-destructure.ts.shot | 66 ++++++++++++ .../fixtures/type-annotation/variable-var.ts | 2 + .../type-annotation/variable-var.ts.shot | 63 +++++++++++ .../fixtures/type-declaration/tuple-rest.ts | 2 + .../type-declaration/tuple-rest.ts.shot | 57 ++++++++++ .../tests/fixtures/type-declaration/tuple.ts | 2 + .../fixtures/type-declaration/tuple.ts.shot | 57 ++++++++++ 26 files changed, 958 insertions(+), 9 deletions(-) create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/parameter.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts create mode 100644 packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts.shot create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/tuple.ts create mode 100644 packages/scope-manager/tests/fixtures/type-declaration/tuple.ts.shot diff --git a/packages/scope-manager/src/referencer/PatternVisitor.ts b/packages/scope-manager/src/referencer/PatternVisitor.ts index cca015e573b..533047f1d24 100644 --- a/packages/scope-manager/src/referencer/PatternVisitor.ts +++ b/packages/scope-manager/src/referencer/PatternVisitor.ts @@ -60,9 +60,7 @@ class PatternVisitor extends VisitorBase { } protected ArrayPattern(pattern: TSESTree.ArrayPattern): void { - for (let i = 0; i < pattern.elements.length; ++i) { - const element = pattern.elements[i]; - + for (const element of pattern.elements) { this.visit(element); } } @@ -134,6 +132,10 @@ class PatternVisitor extends VisitorBase { protected SpreadElement(node: TSESTree.SpreadElement): void { this.visit(node.argument); } + + protected TSTypeAnnotation(): void { + // we don't want to visit types + } } export { PatternVisitor, PatternVisitorCallback, PatternVisitorOptions }; diff --git a/packages/scope-manager/src/referencer/Referencer.ts b/packages/scope-manager/src/referencer/Referencer.ts index 9d001827695..99905479a63 100644 --- a/packages/scope-manager/src/referencer/Referencer.ts +++ b/packages/scope-manager/src/referencer/Referencer.ts @@ -197,19 +197,23 @@ class Referencer extends Visitor { this.scopeManager.nestFunctionScope(node, this.isInnerMethodDefinition); // Process parameter declarations. - for (let i = 0; i < node.params.length; ++i) { + for (const param of node.params) { this.visitPattern( - node.params[i], + param, (pattern, info) => { this.currentScope().defineIdentifier( pattern, new ParameterDefinition(pattern, node, info.rest), ); + this.visitType(pattern.typeAnnotation); this.referencingDefaultValue(pattern, info.assignments, null, true); }, { processRightHandNodes: true }, ); + if ('typeAnnotation' in param) { + this.visitType(param.typeAnnotation); + } } // In TypeScript there are a number of function-like constructs which have no body, @@ -444,6 +448,7 @@ class Referencer extends Visitor { protected Identifier(node: TSESTree.Identifier): void { this.currentScope().referenceValue(node); + this.visitType(node.typeAnnotation); } protected ImportDeclaration(node: TSESTree.ImportDeclaration): void { @@ -520,8 +525,8 @@ class Referencer extends Visitor { this.scopeManager.nestSwitchScope(node); } - for (let i = 0; i < node.cases.length; ++i) { - this.visit(node.cases[i]); + for (const switchCase of node.cases) { + this.visit(switchCase); } this.close(node); @@ -600,8 +605,7 @@ class Referencer extends Visitor { ? this.currentScope().variableScope : this.currentScope(); - for (let i = 0; i < node.declarations.length; ++i) { - const decl = node.declarations[i]; + for (const decl of node.declarations) { const init = decl.init; this.visitPattern( @@ -612,6 +616,7 @@ class Referencer extends Visitor { new VariableDefinition(pattern, decl, node), ); + this.visitType(pattern.typeAnnotation); this.referencingDefaultValue(pattern, info.assignments, null, true); if (init) { this.currentScope().referenceValue( @@ -629,6 +634,10 @@ class Referencer extends Visitor { if (decl.init) { this.visit(decl.init); } + + if ('typeAnnotation' in decl.id) { + this.visitType(decl.id.typeAnnotation); + } } } diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts b/packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts new file mode 100644 index 00000000000..ce717cd0a41 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts @@ -0,0 +1,2 @@ +type T = []; +function foo([a]: T) {} diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts.shot new file mode 100644 index 00000000000..cba775c2caf --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-array-destructure.ts.shot @@ -0,0 +1,91 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation parameter-array-destructure 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + FunctionNameDefinition$2 { + name: Identifier<"foo">, + node: FunctionDeclaration$2, + }, + ], + name: "foo", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + Variable$3 { + defs: Array [], + name: "arguments", + references: Array [], + isValueVariable: true, + isTypeVariable: true, + }, + Variable$4 { + defs: Array [ + ParameterDefinition$3 { + name: Identifier<"a">, + node: FunctionDeclaration$2, + }, + ], + name: "a", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [], + set: Map { + "T" => Variable$1, + "foo" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + FunctionScope$2 { + block: FunctionDeclaration$2, + isStrict: false, + references: Array [ + Reference$1, + ], + set: Map { + "arguments" => Variable$3, + "a" => Variable$4, + }, + type: "function", + upper: GlobalScope$1, + variables: Array [ + Variable$3, + Variable$4, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts b/packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts new file mode 100644 index 00000000000..61c1836be6e --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts @@ -0,0 +1,2 @@ +type T = 1; +function foo(a: T = 1) {} diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts.shot new file mode 100644 index 00000000000..fda3779d541 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-default.ts.shot @@ -0,0 +1,100 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation parameter-default 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + FunctionNameDefinition$2 { + name: Identifier<"foo">, + node: FunctionDeclaration$2, + }, + ], + name: "foo", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + Variable$3 { + defs: Array [], + name: "arguments", + references: Array [], + isValueVariable: true, + isTypeVariable: true, + }, + Variable$4 { + defs: Array [ + ParameterDefinition$3 { + name: Identifier<"a">, + node: FunctionDeclaration$2, + }, + ], + name: "a", + references: Array [ + Reference$2 { + identifier: Identifier<"a">, + init: true, + isTypeReference: false, + resolved: Variable$4, + writeExpr: Literal$3, + }, + ], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$4, + isStrict: false, + references: Array [], + set: Map { + "T" => Variable$1, + "foo" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + FunctionScope$2 { + block: FunctionDeclaration$2, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + ], + set: Map { + "arguments" => Variable$3, + "a" => Variable$4, + }, + type: "function", + upper: GlobalScope$1, + variables: Array [ + Variable$3, + Variable$4, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts b/packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts new file mode 100644 index 00000000000..04824de3762 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts @@ -0,0 +1,2 @@ +type T = {}; +function foo({ a }: T) {} diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts.shot new file mode 100644 index 00000000000..d6d5ec26872 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-object-destructure.ts.shot @@ -0,0 +1,91 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation parameter-object-destructure 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + FunctionNameDefinition$2 { + name: Identifier<"foo">, + node: FunctionDeclaration$2, + }, + ], + name: "foo", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + Variable$3 { + defs: Array [], + name: "arguments", + references: Array [], + isValueVariable: true, + isTypeVariable: true, + }, + Variable$4 { + defs: Array [ + ParameterDefinition$3 { + name: Identifier<"a">, + node: FunctionDeclaration$2, + }, + ], + name: "a", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [], + set: Map { + "T" => Variable$1, + "foo" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + FunctionScope$2 { + block: FunctionDeclaration$2, + isStrict: false, + references: Array [ + Reference$1, + ], + set: Map { + "arguments" => Variable$3, + "a" => Variable$4, + }, + type: "function", + upper: GlobalScope$1, + variables: Array [ + Variable$3, + Variable$4, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts b/packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts new file mode 100644 index 00000000000..426fcd70450 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts @@ -0,0 +1,2 @@ +type T = 1; +function foo(...a: T[]) {} diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts.shot new file mode 100644 index 00000000000..f3cf709d8ca --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter-rest.ts.shot @@ -0,0 +1,91 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation parameter-rest 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + FunctionNameDefinition$2 { + name: Identifier<"foo">, + node: FunctionDeclaration$2, + }, + ], + name: "foo", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + Variable$3 { + defs: Array [], + name: "arguments", + references: Array [], + isValueVariable: true, + isTypeVariable: true, + }, + Variable$4 { + defs: Array [ + ParameterDefinition$3 { + name: Identifier<"a">, + node: FunctionDeclaration$2, + }, + ], + name: "a", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [], + set: Map { + "T" => Variable$1, + "foo" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + FunctionScope$2 { + block: FunctionDeclaration$2, + isStrict: false, + references: Array [ + Reference$1, + ], + set: Map { + "arguments" => Variable$3, + "a" => Variable$4, + }, + type: "function", + upper: GlobalScope$1, + variables: Array [ + Variable$3, + Variable$4, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter.ts b/packages/scope-manager/tests/fixtures/type-annotation/parameter.ts new file mode 100644 index 00000000000..53fd1a252db --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter.ts @@ -0,0 +1,2 @@ +type T = 1; +function foo(a: T) {} diff --git a/packages/scope-manager/tests/fixtures/type-annotation/parameter.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/parameter.ts.shot new file mode 100644 index 00000000000..fecf0e21c44 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/parameter.ts.shot @@ -0,0 +1,97 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation parameter 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + Reference$2 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + FunctionNameDefinition$2 { + name: Identifier<"foo">, + node: FunctionDeclaration$2, + }, + ], + name: "foo", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + Variable$3 { + defs: Array [], + name: "arguments", + references: Array [], + isValueVariable: true, + isTypeVariable: true, + }, + Variable$4 { + defs: Array [ + ParameterDefinition$3 { + name: Identifier<"a">, + node: FunctionDeclaration$2, + }, + ], + name: "a", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [], + set: Map { + "T" => Variable$1, + "foo" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + FunctionScope$2 { + block: FunctionDeclaration$2, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + ], + set: Map { + "arguments" => Variable$3, + "a" => Variable$4, + }, + type: "function", + upper: GlobalScope$1, + variables: Array [ + Variable$3, + Variable$4, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts b/packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts new file mode 100644 index 00000000000..d40a8608f14 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts @@ -0,0 +1,2 @@ +type T = []; +const [x]: T = []; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts.shot new file mode 100644 index 00000000000..840771adbad --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-array-destructure.ts.shot @@ -0,0 +1,66 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation variable-array-destructure 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$2 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + VariableDefinition$2 { + name: Identifier<"x">, + node: VariableDeclarator$2, + }, + ], + name: "x", + references: Array [ + Reference$1 { + identifier: Identifier<"x">, + init: true, + isTypeReference: false, + resolved: Variable$2, + writeExpr: ArrayExpression$3, + }, + ], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$4, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + ], + set: Map { + "T" => Variable$1, + "x" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts b/packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts new file mode 100644 index 00000000000..7b61add80b1 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts @@ -0,0 +1,2 @@ +type T = 1; +const x: T = 1; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts.shot new file mode 100644 index 00000000000..f77f19696ca --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-const.ts.shot @@ -0,0 +1,72 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation variable-const 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + Reference$3 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + VariableDefinition$2 { + name: Identifier<"x">, + node: VariableDeclarator$2, + }, + ], + name: "x", + references: Array [ + Reference$2 { + identifier: Identifier<"x">, + init: true, + isTypeReference: false, + resolved: Variable$2, + writeExpr: Literal$3, + }, + ], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$4, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + Reference$3, + ], + set: Map { + "T" => Variable$1, + "x" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts b/packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts new file mode 100644 index 00000000000..d6b0d69dbbe --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts @@ -0,0 +1,2 @@ +type T = 1; +let x: T; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts.shot new file mode 100644 index 00000000000..b24f16329e6 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-let.ts.shot @@ -0,0 +1,63 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation variable-let 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + Reference$2 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + VariableDefinition$2 { + name: Identifier<"x">, + node: VariableDeclarator$2, + }, + ], + name: "x", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + ], + set: Map { + "T" => Variable$1, + "x" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts b/packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts new file mode 100644 index 00000000000..a0a18b23ab9 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts @@ -0,0 +1,2 @@ +type T = {}; +const { x }: T = {}; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts.shot new file mode 100644 index 00000000000..15ef00f8420 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-object-destructure.ts.shot @@ -0,0 +1,66 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation variable-object-destructure 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$2 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + VariableDefinition$2 { + name: Identifier<"x">, + node: VariableDeclarator$2, + }, + ], + name: "x", + references: Array [ + Reference$1 { + identifier: Identifier<"x">, + init: true, + isTypeReference: false, + resolved: Variable$2, + writeExpr: ObjectExpression$3, + }, + ], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$4, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + ], + set: Map { + "T" => Variable$1, + "x" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts b/packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts new file mode 100644 index 00000000000..4423625dc4c --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts @@ -0,0 +1,2 @@ +type T = 1; +var x: T; diff --git a/packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts.shot b/packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts.shot new file mode 100644 index 00000000000..eee1d4a392d --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-annotation/variable-var.ts.shot @@ -0,0 +1,63 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-annotation variable-var 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + Reference$2 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + VariableDefinition$2 { + name: Identifier<"x">, + node: VariableDeclarator$2, + }, + ], + name: "x", + references: Array [], + isValueVariable: true, + isTypeVariable: false, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [ + Reference$1, + Reference$2, + ], + set: Map { + "T" => Variable$1, + "x" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts b/packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts new file mode 100644 index 00000000000..65c675d09ad --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts @@ -0,0 +1,2 @@ +type T = 1; +type A = [...T]; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts.shot new file mode 100644 index 00000000000..e4b8d2e657f --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/tuple-rest.ts.shot @@ -0,0 +1,57 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-declaration tuple-rest 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + TypeDefinition$2 { + name: Identifier<"A">, + node: TSTypeAliasDeclaration$2, + }, + ], + name: "A", + references: Array [], + isValueVariable: false, + isTypeVariable: true, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [ + Reference$1, + ], + set: Map { + "T" => Variable$1, + "A" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/tuple.ts b/packages/scope-manager/tests/fixtures/type-declaration/tuple.ts new file mode 100644 index 00000000000..87df28769c3 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/tuple.ts @@ -0,0 +1,2 @@ +type T = 1; +type A = [T]; diff --git a/packages/scope-manager/tests/fixtures/type-declaration/tuple.ts.shot b/packages/scope-manager/tests/fixtures/type-declaration/tuple.ts.shot new file mode 100644 index 00000000000..eb98ace5ab4 --- /dev/null +++ b/packages/scope-manager/tests/fixtures/type-declaration/tuple.ts.shot @@ -0,0 +1,57 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`type-declaration tuple 1`] = ` +ScopeManager { + variables: Array [ + Variable$1 { + defs: Array [ + TypeDefinition$1 { + name: Identifier<"T">, + node: TSTypeAliasDeclaration$1, + }, + ], + name: "T", + references: Array [ + Reference$1 { + identifier: Identifier<"T">, + isTypeReference: true, + resolved: Variable$1, + }, + ], + isValueVariable: false, + isTypeVariable: true, + }, + Variable$2 { + defs: Array [ + TypeDefinition$2 { + name: Identifier<"A">, + node: TSTypeAliasDeclaration$2, + }, + ], + name: "A", + references: Array [], + isValueVariable: false, + isTypeVariable: true, + }, + ], + scopes: Array [ + GlobalScope$1 { + block: Program$3, + isStrict: false, + references: Array [ + Reference$1, + ], + set: Map { + "T" => Variable$1, + "A" => Variable$2, + }, + type: "global", + upper: null, + variables: Array [ + Variable$1, + Variable$2, + ], + }, + ], +} +`;