first commit
This commit is contained in:
658
node_modules/tsutils/util/usage.js
generated
vendored
Normal file
658
node_modules/tsutils/util/usage.js
generated
vendored
Normal file
@@ -0,0 +1,658 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.collectVariableUsage = exports.getDeclarationDomain = exports.getUsageDomain = exports.UsageDomain = exports.DeclarationDomain = void 0;
|
||||
const util_1 = require("./util");
|
||||
const ts = require("typescript");
|
||||
var DeclarationDomain;
|
||||
(function (DeclarationDomain) {
|
||||
DeclarationDomain[DeclarationDomain["Namespace"] = 1] = "Namespace";
|
||||
DeclarationDomain[DeclarationDomain["Type"] = 2] = "Type";
|
||||
DeclarationDomain[DeclarationDomain["Value"] = 4] = "Value";
|
||||
DeclarationDomain[DeclarationDomain["Import"] = 8] = "Import";
|
||||
DeclarationDomain[DeclarationDomain["Any"] = 7] = "Any";
|
||||
})(DeclarationDomain = exports.DeclarationDomain || (exports.DeclarationDomain = {}));
|
||||
var UsageDomain;
|
||||
(function (UsageDomain) {
|
||||
UsageDomain[UsageDomain["Namespace"] = 1] = "Namespace";
|
||||
UsageDomain[UsageDomain["Type"] = 2] = "Type";
|
||||
UsageDomain[UsageDomain["Value"] = 4] = "Value";
|
||||
UsageDomain[UsageDomain["ValueOrNamespace"] = 5] = "ValueOrNamespace";
|
||||
UsageDomain[UsageDomain["Any"] = 7] = "Any";
|
||||
UsageDomain[UsageDomain["TypeQuery"] = 8] = "TypeQuery";
|
||||
})(UsageDomain = exports.UsageDomain || (exports.UsageDomain = {}));
|
||||
// TODO handle cases where values are used only for their types, e.g. `declare [propSymbol]: number`
|
||||
function getUsageDomain(node) {
|
||||
const parent = node.parent;
|
||||
switch (parent.kind) {
|
||||
case ts.SyntaxKind.TypeReference:
|
||||
return node.originalKeywordKind !== ts.SyntaxKind.ConstKeyword ? 2 /* Type */ : undefined;
|
||||
case ts.SyntaxKind.ExpressionWithTypeArguments:
|
||||
return parent.parent.token === ts.SyntaxKind.ImplementsKeyword ||
|
||||
parent.parent.parent.kind === ts.SyntaxKind.InterfaceDeclaration
|
||||
? 2 /* Type */
|
||||
: 4 /* Value */;
|
||||
case ts.SyntaxKind.TypeQuery:
|
||||
return 5 /* ValueOrNamespace */ | 8 /* TypeQuery */;
|
||||
case ts.SyntaxKind.QualifiedName:
|
||||
if (parent.left === node) {
|
||||
if (getEntityNameParent(parent).kind === ts.SyntaxKind.TypeQuery)
|
||||
return 1 /* Namespace */ | 8 /* TypeQuery */;
|
||||
return 1 /* Namespace */;
|
||||
}
|
||||
break;
|
||||
case ts.SyntaxKind.ExportSpecifier:
|
||||
// either {name} or {propertyName as name}
|
||||
if (parent.propertyName === undefined ||
|
||||
parent.propertyName === node)
|
||||
return 7 /* Any */; // TODO handle type-only exports
|
||||
break;
|
||||
case ts.SyntaxKind.ExportAssignment:
|
||||
return 7 /* Any */;
|
||||
// Value
|
||||
case ts.SyntaxKind.BindingElement:
|
||||
if (parent.initializer === node)
|
||||
return 5 /* ValueOrNamespace */;
|
||||
break;
|
||||
case ts.SyntaxKind.Parameter:
|
||||
case ts.SyntaxKind.EnumMember:
|
||||
case ts.SyntaxKind.PropertyDeclaration:
|
||||
case ts.SyntaxKind.VariableDeclaration:
|
||||
case ts.SyntaxKind.PropertyAssignment:
|
||||
case ts.SyntaxKind.PropertyAccessExpression:
|
||||
case ts.SyntaxKind.ImportEqualsDeclaration:
|
||||
if (parent.name !== node)
|
||||
return 5 /* ValueOrNamespace */; // TODO handle type-only imports
|
||||
break;
|
||||
case ts.SyntaxKind.JsxAttribute:
|
||||
case ts.SyntaxKind.FunctionDeclaration:
|
||||
case ts.SyntaxKind.FunctionExpression:
|
||||
case ts.SyntaxKind.NamespaceImport:
|
||||
case ts.SyntaxKind.ClassDeclaration:
|
||||
case ts.SyntaxKind.ClassExpression:
|
||||
case ts.SyntaxKind.ModuleDeclaration:
|
||||
case ts.SyntaxKind.MethodDeclaration:
|
||||
case ts.SyntaxKind.EnumDeclaration:
|
||||
case ts.SyntaxKind.GetAccessor:
|
||||
case ts.SyntaxKind.SetAccessor:
|
||||
case ts.SyntaxKind.LabeledStatement:
|
||||
case ts.SyntaxKind.BreakStatement:
|
||||
case ts.SyntaxKind.ContinueStatement:
|
||||
case ts.SyntaxKind.ImportClause:
|
||||
case ts.SyntaxKind.ImportSpecifier:
|
||||
case ts.SyntaxKind.TypePredicate: // TODO this actually references a parameter
|
||||
case ts.SyntaxKind.MethodSignature:
|
||||
case ts.SyntaxKind.PropertySignature:
|
||||
case ts.SyntaxKind.NamespaceExportDeclaration:
|
||||
case ts.SyntaxKind.NamespaceExport:
|
||||
case ts.SyntaxKind.InterfaceDeclaration:
|
||||
case ts.SyntaxKind.TypeAliasDeclaration:
|
||||
case ts.SyntaxKind.TypeParameter:
|
||||
case ts.SyntaxKind.NamedTupleMember:
|
||||
break;
|
||||
default:
|
||||
return 5 /* ValueOrNamespace */;
|
||||
}
|
||||
}
|
||||
exports.getUsageDomain = getUsageDomain;
|
||||
function getDeclarationDomain(node) {
|
||||
switch (node.parent.kind) {
|
||||
case ts.SyntaxKind.TypeParameter:
|
||||
case ts.SyntaxKind.InterfaceDeclaration:
|
||||
case ts.SyntaxKind.TypeAliasDeclaration:
|
||||
return 2 /* Type */;
|
||||
case ts.SyntaxKind.ClassDeclaration:
|
||||
case ts.SyntaxKind.ClassExpression:
|
||||
return 2 /* Type */ | 4 /* Value */;
|
||||
case ts.SyntaxKind.EnumDeclaration:
|
||||
return 7 /* Any */;
|
||||
case ts.SyntaxKind.NamespaceImport:
|
||||
case ts.SyntaxKind.ImportClause:
|
||||
return 7 /* Any */ | 8 /* Import */; // TODO handle type-only imports
|
||||
case ts.SyntaxKind.ImportEqualsDeclaration:
|
||||
case ts.SyntaxKind.ImportSpecifier:
|
||||
return node.parent.name === node
|
||||
? 7 /* Any */ | 8 /* Import */ // TODO handle type-only imports
|
||||
: undefined;
|
||||
case ts.SyntaxKind.ModuleDeclaration:
|
||||
return 1 /* Namespace */;
|
||||
case ts.SyntaxKind.Parameter:
|
||||
if (node.parent.parent.kind === ts.SyntaxKind.IndexSignature || node.originalKeywordKind === ts.SyntaxKind.ThisKeyword)
|
||||
return;
|
||||
// falls through
|
||||
case ts.SyntaxKind.BindingElement:
|
||||
case ts.SyntaxKind.VariableDeclaration:
|
||||
return node.parent.name === node ? 4 /* Value */ : undefined;
|
||||
case ts.SyntaxKind.FunctionDeclaration:
|
||||
case ts.SyntaxKind.FunctionExpression:
|
||||
return 4 /* Value */;
|
||||
}
|
||||
}
|
||||
exports.getDeclarationDomain = getDeclarationDomain;
|
||||
function collectVariableUsage(sourceFile) {
|
||||
return new UsageWalker().getUsage(sourceFile);
|
||||
}
|
||||
exports.collectVariableUsage = collectVariableUsage;
|
||||
class AbstractScope {
|
||||
constructor(_global) {
|
||||
this._global = _global;
|
||||
this._variables = new Map();
|
||||
this._uses = [];
|
||||
this._namespaceScopes = undefined;
|
||||
this._enumScopes = undefined;
|
||||
}
|
||||
addVariable(identifier, name, selector, exported, domain) {
|
||||
const variables = this.getDestinationScope(selector).getVariables();
|
||||
const declaration = {
|
||||
domain,
|
||||
exported,
|
||||
declaration: name,
|
||||
};
|
||||
const variable = variables.get(identifier);
|
||||
if (variable === undefined) {
|
||||
variables.set(identifier, {
|
||||
domain,
|
||||
declarations: [declaration],
|
||||
uses: [],
|
||||
});
|
||||
}
|
||||
else {
|
||||
variable.domain |= domain;
|
||||
variable.declarations.push(declaration);
|
||||
}
|
||||
}
|
||||
addUse(use) {
|
||||
this._uses.push(use);
|
||||
}
|
||||
getVariables() {
|
||||
return this._variables;
|
||||
}
|
||||
getFunctionScope() {
|
||||
return this;
|
||||
}
|
||||
end(cb) {
|
||||
if (this._namespaceScopes !== undefined)
|
||||
this._namespaceScopes.forEach((value) => value.finish(cb));
|
||||
this._namespaceScopes = this._enumScopes = undefined;
|
||||
this._applyUses();
|
||||
this._variables.forEach((variable) => {
|
||||
for (const declaration of variable.declarations) {
|
||||
const result = {
|
||||
declarations: [],
|
||||
domain: declaration.domain,
|
||||
exported: declaration.exported,
|
||||
inGlobalScope: this._global,
|
||||
uses: [],
|
||||
};
|
||||
for (const other of variable.declarations)
|
||||
if (other.domain & declaration.domain)
|
||||
result.declarations.push(other.declaration);
|
||||
for (const use of variable.uses)
|
||||
if (use.domain & declaration.domain)
|
||||
result.uses.push(use);
|
||||
cb(result, declaration.declaration, this);
|
||||
}
|
||||
});
|
||||
}
|
||||
// tslint:disable-next-line:prefer-function-over-method
|
||||
markExported(_name) { } // only relevant for the root scope
|
||||
createOrReuseNamespaceScope(name, _exported, ambient, hasExportStatement) {
|
||||
let scope;
|
||||
if (this._namespaceScopes === undefined) {
|
||||
this._namespaceScopes = new Map();
|
||||
}
|
||||
else {
|
||||
scope = this._namespaceScopes.get(name);
|
||||
}
|
||||
if (scope === undefined) {
|
||||
scope = new NamespaceScope(ambient, hasExportStatement, this);
|
||||
this._namespaceScopes.set(name, scope);
|
||||
}
|
||||
else {
|
||||
scope.refresh(ambient, hasExportStatement);
|
||||
}
|
||||
return scope;
|
||||
}
|
||||
createOrReuseEnumScope(name, _exported) {
|
||||
let scope;
|
||||
if (this._enumScopes === undefined) {
|
||||
this._enumScopes = new Map();
|
||||
}
|
||||
else {
|
||||
scope = this._enumScopes.get(name);
|
||||
}
|
||||
if (scope === undefined) {
|
||||
scope = new EnumScope(this);
|
||||
this._enumScopes.set(name, scope);
|
||||
}
|
||||
return scope;
|
||||
}
|
||||
_applyUses() {
|
||||
for (const use of this._uses)
|
||||
if (!this._applyUse(use))
|
||||
this._addUseToParent(use);
|
||||
this._uses = [];
|
||||
}
|
||||
_applyUse(use, variables = this._variables) {
|
||||
const variable = variables.get(use.location.text);
|
||||
if (variable === undefined || (variable.domain & use.domain) === 0)
|
||||
return false;
|
||||
variable.uses.push(use);
|
||||
return true;
|
||||
}
|
||||
_addUseToParent(_use) { } // tslint:disable-line:prefer-function-over-method
|
||||
}
|
||||
class RootScope extends AbstractScope {
|
||||
constructor(_exportAll, global) {
|
||||
super(global);
|
||||
this._exportAll = _exportAll;
|
||||
this._exports = undefined;
|
||||
this._innerScope = new NonRootScope(this, 1 /* Function */);
|
||||
}
|
||||
addVariable(identifier, name, selector, exported, domain) {
|
||||
if (domain & 8 /* Import */)
|
||||
return super.addVariable(identifier, name, selector, exported, domain);
|
||||
return this._innerScope.addVariable(identifier, name, selector, exported, domain);
|
||||
}
|
||||
addUse(use, origin) {
|
||||
if (origin === this._innerScope)
|
||||
return super.addUse(use);
|
||||
return this._innerScope.addUse(use);
|
||||
}
|
||||
markExported(id) {
|
||||
if (this._exports === undefined) {
|
||||
this._exports = [id.text];
|
||||
}
|
||||
else {
|
||||
this._exports.push(id.text);
|
||||
}
|
||||
}
|
||||
end(cb) {
|
||||
this._innerScope.end((value, key) => {
|
||||
value.exported = value.exported || this._exportAll
|
||||
|| this._exports !== undefined && this._exports.includes(key.text);
|
||||
value.inGlobalScope = this._global;
|
||||
return cb(value, key, this);
|
||||
});
|
||||
return super.end((value, key, scope) => {
|
||||
value.exported = value.exported || scope === this
|
||||
&& this._exports !== undefined && this._exports.includes(key.text);
|
||||
return cb(value, key, scope);
|
||||
});
|
||||
}
|
||||
getDestinationScope() {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
class NonRootScope extends AbstractScope {
|
||||
constructor(_parent, _boundary) {
|
||||
super(false);
|
||||
this._parent = _parent;
|
||||
this._boundary = _boundary;
|
||||
}
|
||||
_addUseToParent(use) {
|
||||
return this._parent.addUse(use, this);
|
||||
}
|
||||
getDestinationScope(selector) {
|
||||
return this._boundary & selector
|
||||
? this
|
||||
: this._parent.getDestinationScope(selector);
|
||||
}
|
||||
}
|
||||
class EnumScope extends NonRootScope {
|
||||
constructor(parent) {
|
||||
super(parent, 1 /* Function */);
|
||||
}
|
||||
end() {
|
||||
this._applyUses();
|
||||
}
|
||||
}
|
||||
class ConditionalTypeScope extends NonRootScope {
|
||||
constructor(parent) {
|
||||
super(parent, 8 /* ConditionalType */);
|
||||
this._state = 0 /* Initial */;
|
||||
}
|
||||
updateState(newState) {
|
||||
this._state = newState;
|
||||
}
|
||||
addUse(use) {
|
||||
if (this._state === 2 /* TrueType */)
|
||||
return void this._uses.push(use);
|
||||
return this._parent.addUse(use, this);
|
||||
}
|
||||
}
|
||||
class FunctionScope extends NonRootScope {
|
||||
constructor(parent) {
|
||||
super(parent, 1 /* Function */);
|
||||
}
|
||||
beginBody() {
|
||||
this._applyUses();
|
||||
}
|
||||
}
|
||||
class AbstractNamedExpressionScope extends NonRootScope {
|
||||
constructor(_name, _domain, parent) {
|
||||
super(parent, 1 /* Function */);
|
||||
this._name = _name;
|
||||
this._domain = _domain;
|
||||
}
|
||||
end(cb) {
|
||||
this._innerScope.end(cb);
|
||||
return cb({
|
||||
declarations: [this._name],
|
||||
domain: this._domain,
|
||||
exported: false,
|
||||
uses: this._uses,
|
||||
inGlobalScope: false,
|
||||
}, this._name, this);
|
||||
}
|
||||
addUse(use, source) {
|
||||
if (source !== this._innerScope)
|
||||
return this._innerScope.addUse(use);
|
||||
if (use.domain & this._domain && use.location.text === this._name.text) {
|
||||
this._uses.push(use);
|
||||
}
|
||||
else {
|
||||
return this._parent.addUse(use, this);
|
||||
}
|
||||
}
|
||||
getFunctionScope() {
|
||||
return this._innerScope;
|
||||
}
|
||||
getDestinationScope() {
|
||||
return this._innerScope;
|
||||
}
|
||||
}
|
||||
class FunctionExpressionScope extends AbstractNamedExpressionScope {
|
||||
constructor(name, parent) {
|
||||
super(name, 4 /* Value */, parent);
|
||||
this._innerScope = new FunctionScope(this);
|
||||
}
|
||||
beginBody() {
|
||||
return this._innerScope.beginBody();
|
||||
}
|
||||
}
|
||||
class ClassExpressionScope extends AbstractNamedExpressionScope {
|
||||
constructor(name, parent) {
|
||||
super(name, 4 /* Value */ | 2 /* Type */, parent);
|
||||
this._innerScope = new NonRootScope(this, 1 /* Function */);
|
||||
}
|
||||
}
|
||||
class BlockScope extends NonRootScope {
|
||||
constructor(_functionScope, parent) {
|
||||
super(parent, 2 /* Block */);
|
||||
this._functionScope = _functionScope;
|
||||
}
|
||||
getFunctionScope() {
|
||||
return this._functionScope;
|
||||
}
|
||||
}
|
||||
function mapDeclaration(declaration) {
|
||||
return {
|
||||
declaration,
|
||||
exported: true,
|
||||
domain: getDeclarationDomain(declaration),
|
||||
};
|
||||
}
|
||||
class NamespaceScope extends NonRootScope {
|
||||
constructor(_ambient, _hasExport, parent) {
|
||||
super(parent, 1 /* Function */);
|
||||
this._ambient = _ambient;
|
||||
this._hasExport = _hasExport;
|
||||
this._innerScope = new NonRootScope(this, 1 /* Function */);
|
||||
this._exports = undefined;
|
||||
}
|
||||
finish(cb) {
|
||||
return super.end(cb);
|
||||
}
|
||||
end(cb) {
|
||||
this._innerScope.end((variable, key, scope) => {
|
||||
if (scope !== this._innerScope ||
|
||||
!variable.exported && (!this._ambient || this._exports !== undefined && !this._exports.has(key.text)))
|
||||
return cb(variable, key, scope);
|
||||
const namespaceVar = this._variables.get(key.text);
|
||||
if (namespaceVar === undefined) {
|
||||
this._variables.set(key.text, {
|
||||
declarations: variable.declarations.map(mapDeclaration),
|
||||
domain: variable.domain,
|
||||
uses: [...variable.uses],
|
||||
});
|
||||
}
|
||||
else {
|
||||
outer: for (const declaration of variable.declarations) {
|
||||
for (const existing of namespaceVar.declarations)
|
||||
if (existing.declaration === declaration)
|
||||
continue outer;
|
||||
namespaceVar.declarations.push(mapDeclaration(declaration));
|
||||
}
|
||||
namespaceVar.domain |= variable.domain;
|
||||
for (const use of variable.uses) {
|
||||
if (namespaceVar.uses.includes(use))
|
||||
continue;
|
||||
namespaceVar.uses.push(use);
|
||||
}
|
||||
}
|
||||
});
|
||||
this._applyUses();
|
||||
this._innerScope = new NonRootScope(this, 1 /* Function */);
|
||||
}
|
||||
createOrReuseNamespaceScope(name, exported, ambient, hasExportStatement) {
|
||||
if (!exported && (!this._ambient || this._hasExport))
|
||||
return this._innerScope.createOrReuseNamespaceScope(name, exported, ambient || this._ambient, hasExportStatement);
|
||||
return super.createOrReuseNamespaceScope(name, exported, ambient || this._ambient, hasExportStatement);
|
||||
}
|
||||
createOrReuseEnumScope(name, exported) {
|
||||
if (!exported && (!this._ambient || this._hasExport))
|
||||
return this._innerScope.createOrReuseEnumScope(name, exported);
|
||||
return super.createOrReuseEnumScope(name, exported);
|
||||
}
|
||||
addUse(use, source) {
|
||||
if (source !== this._innerScope)
|
||||
return this._innerScope.addUse(use);
|
||||
this._uses.push(use);
|
||||
}
|
||||
refresh(ambient, hasExport) {
|
||||
this._ambient = ambient;
|
||||
this._hasExport = hasExport;
|
||||
}
|
||||
markExported(name, _as) {
|
||||
if (this._exports === undefined)
|
||||
this._exports = new Set();
|
||||
this._exports.add(name.text);
|
||||
}
|
||||
getDestinationScope() {
|
||||
return this._innerScope;
|
||||
}
|
||||
}
|
||||
function getEntityNameParent(name) {
|
||||
let parent = name.parent;
|
||||
while (parent.kind === ts.SyntaxKind.QualifiedName)
|
||||
parent = parent.parent;
|
||||
return parent;
|
||||
}
|
||||
// TODO class decorators resolve outside of class, element and parameter decorator resolve inside/at the class
|
||||
// TODO computed property name resolves inside/at the cass
|
||||
// TODO this and super in all of them are resolved outside of the class
|
||||
class UsageWalker {
|
||||
constructor() {
|
||||
this._result = new Map();
|
||||
}
|
||||
getUsage(sourceFile) {
|
||||
const variableCallback = (variable, key) => {
|
||||
this._result.set(key, variable);
|
||||
};
|
||||
const isModule = ts.isExternalModule(sourceFile);
|
||||
this._scope = new RootScope(sourceFile.isDeclarationFile && isModule && !containsExportStatement(sourceFile), !isModule);
|
||||
const cb = (node) => {
|
||||
if (util_1.isBlockScopeBoundary(node))
|
||||
return continueWithScope(node, new BlockScope(this._scope.getFunctionScope(), this._scope), handleBlockScope);
|
||||
switch (node.kind) {
|
||||
case ts.SyntaxKind.ClassExpression:
|
||||
return continueWithScope(node, node.name !== undefined
|
||||
? new ClassExpressionScope(node.name, this._scope)
|
||||
: new NonRootScope(this._scope, 1 /* Function */));
|
||||
case ts.SyntaxKind.ClassDeclaration:
|
||||
this._handleDeclaration(node, true, 4 /* Value */ | 2 /* Type */);
|
||||
return continueWithScope(node, new NonRootScope(this._scope, 1 /* Function */));
|
||||
case ts.SyntaxKind.InterfaceDeclaration:
|
||||
case ts.SyntaxKind.TypeAliasDeclaration:
|
||||
this._handleDeclaration(node, true, 2 /* Type */);
|
||||
return continueWithScope(node, new NonRootScope(this._scope, 4 /* Type */));
|
||||
case ts.SyntaxKind.EnumDeclaration:
|
||||
this._handleDeclaration(node, true, 7 /* Any */);
|
||||
return continueWithScope(node, this._scope.createOrReuseEnumScope(node.name.text, util_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword)));
|
||||
case ts.SyntaxKind.ModuleDeclaration:
|
||||
return this._handleModule(node, continueWithScope);
|
||||
case ts.SyntaxKind.MappedType:
|
||||
return continueWithScope(node, new NonRootScope(this._scope, 4 /* Type */));
|
||||
case ts.SyntaxKind.FunctionExpression:
|
||||
case ts.SyntaxKind.ArrowFunction:
|
||||
case ts.SyntaxKind.Constructor:
|
||||
case ts.SyntaxKind.MethodDeclaration:
|
||||
case ts.SyntaxKind.FunctionDeclaration:
|
||||
case ts.SyntaxKind.GetAccessor:
|
||||
case ts.SyntaxKind.SetAccessor:
|
||||
case ts.SyntaxKind.MethodSignature:
|
||||
case ts.SyntaxKind.CallSignature:
|
||||
case ts.SyntaxKind.ConstructSignature:
|
||||
case ts.SyntaxKind.ConstructorType:
|
||||
case ts.SyntaxKind.FunctionType:
|
||||
return this._handleFunctionLikeDeclaration(node, cb, variableCallback);
|
||||
case ts.SyntaxKind.ConditionalType:
|
||||
return this._handleConditionalType(node, cb, variableCallback);
|
||||
// End of Scope specific handling
|
||||
case ts.SyntaxKind.VariableDeclarationList:
|
||||
this._handleVariableDeclaration(node);
|
||||
break;
|
||||
case ts.SyntaxKind.Parameter:
|
||||
if (node.parent.kind !== ts.SyntaxKind.IndexSignature &&
|
||||
(node.name.kind !== ts.SyntaxKind.Identifier ||
|
||||
node.name.originalKeywordKind !== ts.SyntaxKind.ThisKeyword))
|
||||
this._handleBindingName(node.name, false, false);
|
||||
break;
|
||||
case ts.SyntaxKind.EnumMember:
|
||||
this._scope.addVariable(util_1.getPropertyName(node.name), node.name, 1 /* Function */, true, 4 /* Value */);
|
||||
break;
|
||||
case ts.SyntaxKind.ImportClause:
|
||||
case ts.SyntaxKind.ImportSpecifier:
|
||||
case ts.SyntaxKind.NamespaceImport:
|
||||
case ts.SyntaxKind.ImportEqualsDeclaration:
|
||||
this._handleDeclaration(node, false, 7 /* Any */ | 8 /* Import */);
|
||||
break;
|
||||
case ts.SyntaxKind.TypeParameter:
|
||||
this._scope.addVariable(node.name.text, node.name, node.parent.kind === ts.SyntaxKind.InferType ? 8 /* InferType */ : 7 /* Type */, false, 2 /* Type */);
|
||||
break;
|
||||
case ts.SyntaxKind.ExportSpecifier:
|
||||
if (node.propertyName !== undefined)
|
||||
return this._scope.markExported(node.propertyName, node.name);
|
||||
return this._scope.markExported(node.name);
|
||||
case ts.SyntaxKind.ExportAssignment:
|
||||
if (node.expression.kind === ts.SyntaxKind.Identifier)
|
||||
return this._scope.markExported(node.expression);
|
||||
break;
|
||||
case ts.SyntaxKind.Identifier:
|
||||
const domain = getUsageDomain(node);
|
||||
if (domain !== undefined)
|
||||
this._scope.addUse({ domain, location: node });
|
||||
return;
|
||||
}
|
||||
return ts.forEachChild(node, cb);
|
||||
};
|
||||
const continueWithScope = (node, scope, next = forEachChild) => {
|
||||
const savedScope = this._scope;
|
||||
this._scope = scope;
|
||||
next(node);
|
||||
this._scope.end(variableCallback);
|
||||
this._scope = savedScope;
|
||||
};
|
||||
const handleBlockScope = (node) => {
|
||||
if (node.kind === ts.SyntaxKind.CatchClause && node.variableDeclaration !== undefined)
|
||||
this._handleBindingName(node.variableDeclaration.name, true, false);
|
||||
return ts.forEachChild(node, cb);
|
||||
};
|
||||
ts.forEachChild(sourceFile, cb);
|
||||
this._scope.end(variableCallback);
|
||||
return this._result;
|
||||
function forEachChild(node) {
|
||||
return ts.forEachChild(node, cb);
|
||||
}
|
||||
}
|
||||
_handleConditionalType(node, cb, varCb) {
|
||||
const savedScope = this._scope;
|
||||
const scope = this._scope = new ConditionalTypeScope(savedScope);
|
||||
cb(node.checkType);
|
||||
scope.updateState(1 /* Extends */);
|
||||
cb(node.extendsType);
|
||||
scope.updateState(2 /* TrueType */);
|
||||
cb(node.trueType);
|
||||
scope.updateState(3 /* FalseType */);
|
||||
cb(node.falseType);
|
||||
scope.end(varCb);
|
||||
this._scope = savedScope;
|
||||
}
|
||||
_handleFunctionLikeDeclaration(node, cb, varCb) {
|
||||
if (node.decorators !== undefined)
|
||||
node.decorators.forEach(cb);
|
||||
const savedScope = this._scope;
|
||||
if (node.kind === ts.SyntaxKind.FunctionDeclaration)
|
||||
this._handleDeclaration(node, false, 4 /* Value */);
|
||||
const scope = this._scope = node.kind === ts.SyntaxKind.FunctionExpression && node.name !== undefined
|
||||
? new FunctionExpressionScope(node.name, savedScope)
|
||||
: new FunctionScope(savedScope);
|
||||
if (node.name !== undefined)
|
||||
cb(node.name);
|
||||
if (node.typeParameters !== undefined)
|
||||
node.typeParameters.forEach(cb);
|
||||
node.parameters.forEach(cb);
|
||||
if (node.type !== undefined)
|
||||
cb(node.type);
|
||||
if (node.body !== undefined) {
|
||||
scope.beginBody();
|
||||
cb(node.body);
|
||||
}
|
||||
scope.end(varCb);
|
||||
this._scope = savedScope;
|
||||
}
|
||||
_handleModule(node, next) {
|
||||
if (node.flags & ts.NodeFlags.GlobalAugmentation)
|
||||
return next(node, this._scope.createOrReuseNamespaceScope('-global', false, true, false));
|
||||
if (node.name.kind === ts.SyntaxKind.Identifier) {
|
||||
const exported = isNamespaceExported(node);
|
||||
this._scope.addVariable(node.name.text, node.name, 1 /* Function */, exported, 1 /* Namespace */ | 4 /* Value */);
|
||||
const ambient = util_1.hasModifier(node.modifiers, ts.SyntaxKind.DeclareKeyword);
|
||||
return next(node, this._scope.createOrReuseNamespaceScope(node.name.text, exported, ambient, ambient && namespaceHasExportStatement(node)));
|
||||
}
|
||||
return next(node, this._scope.createOrReuseNamespaceScope(`"${node.name.text}"`, false, true, namespaceHasExportStatement(node)));
|
||||
}
|
||||
_handleDeclaration(node, blockScoped, domain) {
|
||||
if (node.name !== undefined)
|
||||
this._scope.addVariable(node.name.text, node.name, blockScoped ? 3 /* Block */ : 1 /* Function */, util_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword), domain);
|
||||
}
|
||||
_handleBindingName(name, blockScoped, exported) {
|
||||
if (name.kind === ts.SyntaxKind.Identifier)
|
||||
return this._scope.addVariable(name.text, name, blockScoped ? 3 /* Block */ : 1 /* Function */, exported, 4 /* Value */);
|
||||
util_1.forEachDestructuringIdentifier(name, (declaration) => {
|
||||
this._scope.addVariable(declaration.name.text, declaration.name, blockScoped ? 3 /* Block */ : 1 /* Function */, exported, 4 /* Value */);
|
||||
});
|
||||
}
|
||||
_handleVariableDeclaration(declarationList) {
|
||||
const blockScoped = util_1.isBlockScopedVariableDeclarationList(declarationList);
|
||||
const exported = declarationList.parent.kind === ts.SyntaxKind.VariableStatement &&
|
||||
util_1.hasModifier(declarationList.parent.modifiers, ts.SyntaxKind.ExportKeyword);
|
||||
for (const declaration of declarationList.declarations)
|
||||
this._handleBindingName(declaration.name, blockScoped, exported);
|
||||
}
|
||||
}
|
||||
function isNamespaceExported(node) {
|
||||
return node.parent.kind === ts.SyntaxKind.ModuleDeclaration || util_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword);
|
||||
}
|
||||
function namespaceHasExportStatement(ns) {
|
||||
if (ns.body === undefined || ns.body.kind !== ts.SyntaxKind.ModuleBlock)
|
||||
return false;
|
||||
return containsExportStatement(ns.body);
|
||||
}
|
||||
function containsExportStatement(block) {
|
||||
for (const statement of block.statements)
|
||||
if (statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
//# sourceMappingURL=usage.js.map
|
||||
Reference in New Issue
Block a user