2021-07-27 16:54:26 +00:00
"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