Lines Matching refs:node
152 …constructor(name: string, node: Node, type: ScopeKind, lexicalScope: boolean = false, upper?: Scop…
155 this.block = node;
235 …export function createLabel(node: LabeledStatement, scope: Scope, parent?: Label | undefined): Lab…
236 let labelName: string = '$' + scope.labels.length + '_' + node.label.text;
238 'name': node.label.text,
240 'refs': [node.label],
276 getScopeOfNode(node: Node): Scope | undefined;
310 function addSymbolInScope(node: Node): void {
311 let defSymbols: SymbolTable = node?.locals;
344 function addExportSymbolInScope(node: Node): void {
345 let defSymbols: Symbol = node?.symbol;
357 function analyzeScope(node: Node): void {
358 switch (node.kind) {
361 analyzeSourceFile(node as SourceFile);
366 analyzeModule(node as ModuleDeclaration);
377 analyzeFunctionLike(node as FunctionLikeDeclaration);
384 analyzeClassLike(node as ClassLikeDeclaration);
391 analyzeForLike(node as ForLikeStatement);
395 analyzeSwitch(node as CaseBlock);
399 analyzeBlock(node);
403 analyzeInterface(node as InterfaceDeclaration);
407 analyzeEnum(node as EnumDeclaration);
411 analyzeSymbol(node as Identifier);
415 analyzeTypeAliasDeclaration(node as TypeAliasDeclaration);
419 analyzeLabel(node as LabeledStatement);
424 analyzeBreakOrContinue(node as BreakOrContinueStatement);
427 analyzeImportNames(node as ImportSpecifier);
431 analyzeObjectBindingPatternRequire(node as ObjectBindingPattern);
435 analyzeObjectLiteralExpression(node as ObjectLiteralExpression);
439 analyzeExportNames(node as ExportSpecifier);
443 analyzeNamespaceExport(node as NamespaceExport);
447 analyzeCatchClause(node as CatchClause);
450 forEachChild(node, analyzeScope);
455 function analyzeImportNames(node: ImportSpecifier): void {
457 const propetyNameNode: Identifier | undefined = node.propertyName;
466 const nameSymbol = checker.getSymbolAtLocation(node.name);
471 const nameText = propetyNameNode ? propetyNameNode.text : node.name.text;
475 forEachChild(node, analyzeScope);
486 function analyzeObjectBindingPatternRequire(node: ObjectBindingPattern): void {
487 if (!NodeUtils.isObjectBindingPatternAssignment(node)) {
488 forEachChild(node, analyzeScope);
492 if (!node.elements) {
496 node.elements.forEach((bindingElement) => {
516 function analyzeObjectLiteralExpression(node: ObjectLiteralExpression): void {
518 current = new Scope(scopeName, node, ScopeKind.OBJECT_LITERAL, false, current);
521 addSymbolInScope(node);
522 forEachChild(node, analyzeScope);
526 function analyzeExportNames(node: ExportSpecifier): void {
528 current.exportNames.add(node.name.text);
529 root.fileExportNames.add(node.name.text);
530 addExportSymbolInScope(node);
531 const propetyNameNode: Identifier | undefined = node.propertyName;
538 forEachChild(node, analyzeScope);
541 function analyzeNamespaceExport(node: NamespaceExport): void {
546 let symbol = checker.getSymbolAtLocation(node.name);
552 function analyzeBreakOrContinue(node: BreakOrContinueStatement): void {
553 let labelName: string = node?.label?.text ?? '';
559 if (node.label) {
560 label?.refs.push(node.label);
563 forEachChild(node, analyzeScope);
580 function analyzeSourceFile(node: SourceFile): void {
582 root = new Scope(scopeName, node, ScopeKind.GLOBAL, true);
588 addSymbolInScope(node);
589 forEachChild(node, analyzeScope);
594 function analyzeCatchClause(node: CatchClause): void {
596 current = new Scope(scopeName, node, ScopeKind.CATCH, false, current);
599 addSymbolInScope(node);
600 if (node.block) {
602 addSymbolInScope(node.block);
605 forEachChild(node, analyzeScope);
625 function analyzeTypeAliasDeclaration(node: TypeAliasDeclaration): void {
626 let scopeName: string = node.name.text ?? '$' + current.children.length;
627 current = new Scope(scopeName, node, ScopeKind.INTERFACE, true, current);
629 addSymbolInScope(node);
630 forEachChild(node, analyzeScope);
640 function analyzeModule(node: ModuleDeclaration): void {
645 let scopeName: string = node.name.text ?? '$' + current.children.length;
646 current = new Scope(scopeName, node, ScopeKind.MODULE, true, current);
648 addSymbolInScope(node);
649 node.forEachChild((sub: Node) => {
663 function excludeConstructorParameter(node: Node): void {
664 if (!isConstructorDeclaration(node)) {
687 node.parameters.forEach((param) => {
698 function analyzeFunctionLike(node: FunctionLikeDeclaration): void {
701 if (getOriginalNode(node).virtual) {
704 let scopeName: string = (node?.name as Identifier)?.text ?? '$' + current.children.length;
716 current = new Scope(scopeName, node, ScopeKind.FUNCTION, true, current);
721 … if ((isFunctionExpression(node) || isArrowFunction(node)) && isVariableDeclaration(node.parent)) {
722 symbol = checker.getSymbolAtLocation(node.name ? node.name : node.parent.name);
724 if (isFunctionDeclaration(node)) {
725 symbol = NodeUtils.findSymbolOfIdentifier(checker, node.name);
727 symbol = checker.getSymbolAtLocation(node.name);
734 addSymbolInScope(node);
742 …if (!(isGetAccessor(node) || isSetAccessor(node)) && symbol && current.parent && !current.parent.d…
752 if (isFunctionDeclaration(node) || isMethodDeclaration(node)) {
754 node.forEachChild((sub: Node) => {
763 forEachChild(node, analyzeScope);
766 excludeConstructorParameter(node);
770 function analyzeSwitch(node: CaseBlock): void {
772 current = new Scope(scopeName, node, ScopeKind.SWITCH, false, current);
774 addSymbolInScope(node);
775 forEachChild(node, analyzeScope);
785 function analyzeClassLike(node: ClassLikeDeclaration): void {
786 if (isClassDeclaration(node) && isViewPUBasedClass(node)) {
787 reservedNames.add(node.name.text);
791 let scopeName: string = node?.name?.text ?? '$' + current.children.length;
792 current = new Scope(scopeName, node, ScopeKind.CLASS, true, current);
794 addSymbolInScope(node);
796 node.members?.forEach((elm: ClassElement) => {
803 forEachChild(node, analyzeScope);
811 function analyzeForLike(node: ForLikeStatement): void {
813 current = new Scope(scopeName, node, ScopeKind.FOR, false, current);
815 addSymbolInScope(node);
816 forEachChild(node, analyzeScope);
820 function analyzeBlock(node: Node): void {
822 if ((isFunctionScope(current) && isFunctionLike(node.parent)) || isCatchClause(node.parent)) {
824 forEachChild(node, analyzeScope);
829 current = new Scope(scopeName, node, ScopeKind.BLOCK, false, current);
831 addSymbolInScope(node);
832 forEachChild(node, analyzeScope);
836 function analyzeInterface(node: InterfaceDeclaration): void {
837 let scopeName: string = node.name.text;
838 current = new Scope(scopeName, node, ScopeKind.INTERFACE, true, current);
841 addSymbolInScope(node);
846 node.members?.forEach((elm: TypeElement) => {
852 forEachChild(node, analyzeScope);
856 function analyzeEnum(node: EnumDeclaration): void {
857 let scopeName: string = node.name.text;
858 current = new Scope(scopeName, node, ScopeKind.ENUM, true, current);
860 for (const member of node.members) {
866 forEachChild(node, analyzeScope);
870 function analyzeSymbol(node: Identifier): void {
872 if (NodeUtils.isPropertyAccessNode(node)) {
879 symbol = NodeUtils.findSymbolOfIdentifier(checker, node);
886 current.mangledNames.add(node.text);
891 if (NodeUtils.isPropertyDeclarationNode(node)) {
896 addSymbolIntoDefsIfNeeded(node, symbol, current.defs);
899 …function addSymbolIntoDefsIfNeeded(node: Identifier, symbol: Symbol, currentDefs: Set<Symbol>): bo…
903 if (def.name === node.text) {
924 function analyzeLabel(node: LabeledStatement): void {
926 upperLabel = upperLabel ? createLabel(node, current, upperLabel) : createLabel(node, current);
927 forEachChild(node, analyzeScope);
931 function getScopeOfNode(node: Node): Scope | undefined {
932 if (!isIdentifier(node)) {
936 let sym: Symbol = checker.getSymbolAtLocation(node);
950 function tryAddNoSymbolIdentifiers(node: Identifier): void {
951 if (!isIdentifier(node)) {
956 if (NodeUtils.isPropertyAccessNode(node)) {
960 const sym: Symbol | undefined = checker.getSymbolAtLocation(node);
962 current.mangledNames.add((node as Identifier).text);
966 function findNoSymbolIdentifiers(node: Node): void {
975 noSymbolVisit(node);