@flint.fyi/typescript-language 0.18.2 → 0.18.3

package/lib/scope/identifierReferences.js

@@ -0,0 +1,91 @@
+import { SyntaxKind } from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/scope/identifierReferences.ts
+function isNonReferenceIdentifier(identifier) {
+	if (isIdentifierDeclaration(identifier) || isTypeReferenceIdentifier(identifier)) return true;
+	const { parent } = identifier;
+	switch (parent.kind) {
+		case SyntaxKind.BindingElement:
+		case SyntaxKind.ImportSpecifier: return parent.propertyName === identifier;
+		case SyntaxKind.BreakStatement:
+		case SyntaxKind.ContinueStatement:
+		case SyntaxKind.LabeledStatement: return parent.label === identifier;
+		case SyntaxKind.JsxAttribute:
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.MethodSignature:
+		case SyntaxKind.PropertyAccessExpression:
+		case SyntaxKind.PropertyAssignment:
+		case SyntaxKind.PropertyDeclaration:
+		case SyntaxKind.PropertySignature: return parent.name === identifier;
+	}
+	return false;
+}
+function isWriteReference(identifier) {
+	const { parent } = identifier;
+	if (isAssignmentTarget(identifier)) return true;
+	switch (parent.kind) {
+		case SyntaxKind.PostfixUnaryExpression:
+		case SyntaxKind.PrefixUnaryExpression: return parent.operand === identifier && (parent.operator === SyntaxKind.PlusPlusToken || parent.operator === SyntaxKind.MinusMinusToken);
+		default: return false;
+	}
+}
+function isAssignmentTarget(identifier) {
+	let current = identifier;
+	while (true) {
+		const parent = current.parent;
+		switch (parent.kind) {
+			case SyntaxKind.ArrayLiteralExpression:
+			case SyntaxKind.ObjectLiteralExpression:
+			case SyntaxKind.ShorthandPropertyAssignment:
+				current = parent;
+				continue;
+			case SyntaxKind.PropertyAssignment:
+				if (parent.name === current) return false;
+				current = parent;
+				continue;
+			case SyntaxKind.BinaryExpression: return parent.left === current && tsutils.isAssignmentKind(parent.operatorToken.kind);
+			case SyntaxKind.ForInStatement:
+			case SyntaxKind.ForOfStatement: return parent.initializer === current;
+		}
+		return false;
+	}
+}
+function isIdentifierDeclaration(identifier) {
+	const { parent } = identifier;
+	switch (parent.kind) {
+		case SyntaxKind.BindingElement:
+		case SyntaxKind.Parameter:
+		case SyntaxKind.VariableDeclaration: return isIdentifierWithinParent(identifier, parent.name);
+		case SyntaxKind.ClassDeclaration:
+		case SyntaxKind.ClassExpression:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.FunctionExpression:
+		case SyntaxKind.InterfaceDeclaration:
+		case SyntaxKind.ModuleDeclaration:
+		case SyntaxKind.TypeAliasDeclaration: return parent.name === identifier;
+		case SyntaxKind.ImportClause:
+		case SyntaxKind.ImportSpecifier:
+		case SyntaxKind.NamespaceImport: return parent.name === identifier;
+	}
+	return false;
+}
+function isIdentifierWithinParent(identifier, parent) {
+	let current = identifier;
+	while (current !== parent) {
+		const next = current.parent;
+		if (!next) return false;
+		current = next;
+	}
+	return true;
+}
+function isTypeReferenceIdentifier(identifier) {
+	let current = identifier;
+	while (current.parent.kind === SyntaxKind.QualifiedName) current = current.parent;
+	const parent = current.parent;
+	if (parent.kind !== SyntaxKind.TypeReference) return false;
+	return isIdentifierWithinParent(identifier, parent.typeName);
+}
+//#endregion
+export { isNonReferenceIdentifier, isWriteReference };
+
+//# sourceMappingURL=identifierReferences.js.map

package/lib/scope/scopeManager.d.ts

@@ -0,0 +1,15 @@
+import { AnyNode, Identifier, SourceFile } from "../types/ast.js";
+import { FunctionWithParameters, Scope, ScopeInternal, ScopeManager, ScopeReference, ScopeVariable } from "./types.js";
+
+//#region src/scope/scopeManager.d.ts
+declare function createScopeManager(sourceFile: SourceFile): {
+  findVariable(identifier: Identifier): ScopeVariable | undefined;
+  getDeclaredVariables(node: AnyNode): ScopeVariable[];
+  getReferencesInScope(node: AnyNode): ScopeReference[];
+  getScope(node: AnyNode): ScopeInternal;
+  globalScope: ScopeInternal;
+};
+declare function getScopeManager(sourceFile: SourceFile): ScopeManager;
+//#endregion
+export { createScopeManager, getScopeManager };
+//# sourceMappingURL=scopeManager.d.ts.map

package/lib/scope/scopeManager.js

@@ -0,0 +1,149 @@
+import { forEachChild } from "../utils/forEachChild.js";
+import { isNonReferenceIdentifier, isWriteReference } from "./identifierReferences.js";
+import { createScope, getReferencesInScope, getVariableDeclarationScope, isScopeBoundary, resolveVariable } from "./scopes.js";
+import { SyntaxKind } from "typescript";
+//#region src/scope/scopeManager.ts
+const scopeManagers = /* @__PURE__ */ new WeakMap();
+function createScopeManager(sourceFile) {
+	const declarationVariablesByIdentifier = /* @__PURE__ */ new WeakMap();
+	const declaredVariablesByNode = /* @__PURE__ */ new WeakMap();
+	const nodeScopes = /* @__PURE__ */ new WeakMap();
+	const globalScope = createScope(sourceFile, void 0);
+	function addBindingName(scope, name, node) {
+		if (name.kind === SyntaxKind.Identifier) return [addVariable(scope, name, node)];
+		const variables = [];
+		for (const element of name.elements) if (element.kind !== SyntaxKind.OmittedExpression) variables.push(...addBindingName(scope, element.name, node));
+		return variables;
+	}
+	function addImportVariables(scope, node) {
+		if (!node.importClause || node.importClause.isTypeOnly) return;
+		if (node.importClause.name) addVariable(scope, node.importClause.name, node);
+		const { namedBindings } = node.importClause;
+		if (!namedBindings) return;
+		if (namedBindings.kind === SyntaxKind.NamespaceImport) {
+			addVariable(scope, namedBindings.name, node);
+			return;
+		}
+		for (const element of namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			addVariable(scope, element.name, node);
+		}
+	}
+	function addParameters(scope, node) {
+		for (const parameter of node.parameters) {
+			const variables = addBindingName(scope, parameter.name, node);
+			declaredVariablesByNode.set(parameter, variables);
+		}
+	}
+	function addVariable(scope, identifier, node) {
+		let variable = scope.variablesByName.get(identifier.text);
+		if (!variable) {
+			variable = {
+				declarations: [],
+				name: identifier.text,
+				references: [],
+				scope
+			};
+			scope.variablesByName.set(identifier.text, variable);
+			scope.variables.push(variable);
+		}
+		variable.declarations.push(identifier);
+		declarationVariablesByIdentifier.set(identifier, variable);
+		const declaredVariables = declaredVariablesByNode.get(node) ?? [];
+		declaredVariables.push(variable);
+		declaredVariablesByNode.set(node, declaredVariables);
+		return variable;
+	}
+	function collectDeclarations(node, scope) {
+		const nodeScope = node !== sourceFile && isScopeBoundary(node) ? createScope(node, scope) : scope;
+		nodeScopes.set(node, nodeScope);
+		switch (node.kind) {
+			case SyntaxKind.ArrowFunction:
+			case SyntaxKind.Constructor:
+			case SyntaxKind.GetAccessor:
+			case SyntaxKind.MethodDeclaration:
+			case SyntaxKind.SetAccessor:
+				addParameters(nodeScope, node);
+				break;
+			case SyntaxKind.CatchClause:
+				if (node.variableDeclaration) addBindingName(nodeScope, node.variableDeclaration.name, node);
+				break;
+			case SyntaxKind.ClassDeclaration:
+				if (node.name) addVariable(nodeScope, node.name, node);
+				break;
+			case SyntaxKind.ClassExpression:
+				if (node.name) addVariable(nodeScope, node.name, node);
+				break;
+			case SyntaxKind.FunctionDeclaration:
+				if (node.name) addVariable(scope, node.name, node);
+				addParameters(nodeScope, node);
+				break;
+			case SyntaxKind.FunctionExpression:
+				if (node.name) addVariable(nodeScope, node.name, node);
+				addParameters(nodeScope, node);
+				break;
+			case SyntaxKind.ImportDeclaration:
+				addImportVariables(nodeScope, node);
+				break;
+			case SyntaxKind.VariableDeclaration:
+				if (node.parent.kind === SyntaxKind.CatchClause) {
+					forEachChild(node, (child) => {
+						collectDeclarations(child, nodeScope);
+					});
+					return;
+				}
+				addBindingName(getVariableDeclarationScope(node, nodeScope), node.name, node);
+				break;
+		}
+		forEachChild(node, (child) => {
+			collectDeclarations(child, nodeScope);
+		});
+	}
+	function collectReferences(node) {
+		if (node.kind === SyntaxKind.Identifier && !isNonReferenceIdentifier(node)) {
+			const scope = nodeScopes.get(node) ?? globalScope;
+			const variable = resolveVariable(scope, node.text);
+			const reference = {
+				from: scope,
+				identifier: node,
+				isWrite: isWriteReference(node),
+				text: node.text,
+				variable
+			};
+			scope.references.push(reference);
+			variable?.references.push(reference);
+		}
+		forEachChild(node, collectReferences);
+	}
+	collectDeclarations(sourceFile, globalScope);
+	collectReferences(sourceFile);
+	return {
+		findVariable(identifier) {
+			const declarationVariable = declarationVariablesByIdentifier.get(identifier);
+			if (declarationVariable) return declarationVariable;
+			return resolveVariable(nodeScopes.get(identifier) ?? globalScope, identifier.text);
+		},
+		getDeclaredVariables(node) {
+			return declaredVariablesByNode.get(node) ?? [];
+		},
+		getReferencesInScope(node) {
+			return getReferencesInScope(nodeScopes.get(node) ?? globalScope);
+		},
+		getScope(node) {
+			return nodeScopes.get(node) ?? globalScope;
+		},
+		globalScope
+	};
+}
+function getScopeManager(sourceFile) {
+	let scopeManager = scopeManagers.get(sourceFile);
+	if (!scopeManager) {
+		scopeManager = createScopeManager(sourceFile);
+		scopeManagers.set(sourceFile, scopeManager);
+	}
+	return scopeManager;
+}
+//#endregion
+export { createScopeManager, getScopeManager };
+
+//# sourceMappingURL=scopeManager.js.map

package/lib/scope/scopes.d.ts

@@ -0,0 +1,8 @@
+import type * as AST from "../types/ast.ts";
+import type { ScopeInternal, ScopeVariable } from "./types.ts";
+export declare function createScope(block: AST.AnyNode, upper: ScopeInternal | undefined): ScopeInternal;
+export declare function getReferencesInScope(scope: ScopeInternal): import("./types.ts").ScopeReference[];
+export declare function getVariableDeclarationScope(node: AST.VariableDeclaration, scope: ScopeInternal): ScopeInternal;
+export declare function isScopeBoundary(node: AST.AnyNode): boolean;
+export declare function resolveVariable(scope: ScopeInternal, name: string): ScopeVariable | undefined;
+//# sourceMappingURL=scopes.d.ts.map

package/lib/scope/scopes.js

@@ -0,0 +1,66 @@
+import ts, { SyntaxKind } from "typescript";
+//#region src/scope/scopes.ts
+function createScope(block, upper) {
+	const variablesByName = /* @__PURE__ */ new Map();
+	const scope = {
+		block,
+		childScopes: [],
+		references: [],
+		upper,
+		variables: [],
+		variablesByName
+	};
+	Object.defineProperty(scope, "variablesByName", {
+		enumerable: false,
+		value: variablesByName
+	});
+	upper?.childScopes.push(scope);
+	return scope;
+}
+function getReferencesInScope(scope) {
+	const references = [...scope.references];
+	for (const childScope of scope.childScopes) if (!isFunctionLike(childScope.block)) references.push(...getReferencesInScope(childScope));
+	return references;
+}
+function getVariableDeclarationScope(node, scope) {
+	if (node.parent.kind === SyntaxKind.VariableDeclarationList && !(node.parent.flags & ts.NodeFlags.BlockScoped)) return findContainingVariableScope(scope);
+	return scope;
+}
+function isScopeBoundary(node) {
+	return isFunctionLike(node) || node.kind === SyntaxKind.CatchClause || node.kind === SyntaxKind.ClassExpression || node.kind === SyntaxKind.ForInStatement || node.kind === SyntaxKind.ForOfStatement || node.kind === SyntaxKind.ForStatement || isBlockScopeBoundary(node);
+}
+function resolveVariable(scope, name) {
+	let current = scope;
+	while (current) {
+		const variable = current.variablesByName.get(name);
+		if (variable) return variable;
+		current = current.upper;
+	}
+}
+function findContainingVariableScope(scope) {
+	let current = scope;
+	while (current.upper && !isVariableScopeBoundary(current.block)) current = current.upper;
+	return current;
+}
+function isBlockScopeBoundary(node) {
+	return node.kind === SyntaxKind.Block && node.parent.kind !== SyntaxKind.CatchClause && !isFunctionLike(node.parent);
+}
+function isFunctionLike(node) {
+	switch (node?.kind) {
+		case SyntaxKind.ArrowFunction:
+		case SyntaxKind.Constructor:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.FunctionExpression:
+		case SyntaxKind.GetAccessor:
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.SetAccessor: return true;
+		default: return false;
+	}
+}
+function isVariableScopeBoundary(node) {
+	return node.kind === SyntaxKind.SourceFile || isFunctionLike(node);
+}
+//#endregion
+export { createScope, getReferencesInScope, getVariableDeclarationScope, isScopeBoundary, resolveVariable };
+
+//# sourceMappingURL=scopes.js.map

package/lib/scope/types.d.ts

@@ -0,0 +1,39 @@
+import { AnyNode, ArrowFunction, ConstructorDeclaration, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, MethodDeclaration, SetAccessorDeclaration } from "../types/ast.js";
+
+//#region src/scope/types.d.ts
+type FunctionWithParameters = ArrowFunction | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | GetAccessorDeclaration | MethodDeclaration | SetAccessorDeclaration;
+interface Scope {
+  block: AnyNode;
+  childScopes: Scope[];
+  references: ScopeReference[];
+  upper: Scope | undefined;
+  variables: ScopeVariable[];
+}
+interface ScopeInternal extends Scope {
+  childScopes: ScopeInternal[];
+  upper: ScopeInternal | undefined;
+  variablesByName: Map<string, ScopeVariable>;
+}
+interface ScopeManager {
+  findVariable(identifier: Identifier): ScopeVariable | undefined;
+  getDeclaredVariables(node: AnyNode): ScopeVariable[];
+  getReferencesInScope(node: AnyNode): ScopeReference[];
+  getScope(node: AnyNode): Scope;
+  globalScope: Scope;
+}
+interface ScopeReference {
+  from: Scope;
+  identifier: Identifier;
+  isWrite: boolean;
+  text: string;
+  variable: ScopeVariable | undefined;
+}
+interface ScopeVariable {
+  declarations: Identifier[];
+  name: string;
+  references: ScopeReference[];
+  scope: Scope;
+}
+//#endregion
+export { FunctionWithParameters, Scope, ScopeInternal, ScopeManager, ScopeReference, ScopeVariable };
+//# sourceMappingURL=types.d.ts.map

package/lib/types/ast.d.ts

@@ -1662,6 +1662,7 @@ interface SourceFile extends ts.Node {
   libReferenceDirectives: readonly ts.FileReference[];
   moduleName?: string;
   readonly parent: NullNode;
+  path: ts.Path;
   referencedFiles: readonly ts.FileReference[];
   readonly statements: ts.NodeArray<Statement>;
   text: string;

package/lib/utils/forEachChild.d.ts

@@ -0,0 +1,8 @@
+import { AnyNode } from "../types/ast.js";
+import ts from "typescript";
+
+//#region src/utils/forEachChild.d.ts
+declare const forEachChild: <T>(node: AnyNode, cbNode: (node: AnyNode) => T | undefined, cbNodes?: (nodes: ts.NodeArray<AnyNode>) => T | undefined) => T | undefined;
+//#endregion
+export { forEachChild };
+//# sourceMappingURL=forEachChild.d.ts.map

package/lib/utils/forEachChild.js

@@ -0,0 +1,7 @@
+import ts from "typescript";
+//#region src/utils/forEachChild.ts
+const forEachChild = ts.forEachChild;
+//#endregion
+export { forEachChild };
+
+//# sourceMappingURL=forEachChild.js.map

package/lib/utils/getModifyingReferences.d.ts

@@ -1,15 +1,11 @@
 import { Identifier, SourceFile } from "../types/ast.js";
-import { Checker } from "../types/checker.js";
-import ts from "typescript";
 
 //#region src/utils/getModifyingReferences.d.ts
 /**
  * Gets all references to a variable that modify it (assignments, increments, decrements).
- *
- * TODO: Replace with a proper scope manager when available (see #400).
  * @returns An array of identifier nodes that modify the variable.
  */
-declare function getModifyingReferences(identifier: Identifier, sourceFile: SourceFile, typeChecker: Checker): ts.Identifier[];
+declare function getModifyingReferences(identifier: Identifier, sourceFile: SourceFile): Identifier[];
 //#endregion
 export { getModifyingReferences };
 //# sourceMappingURL=getModifyingReferences.d.ts.map

package/lib/utils/getModifyingReferences.js

@@ -1,33 +1,13 @@
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
+import { getScopeManager } from "../scope/scopeManager.js";
 //#region src/utils/getModifyingReferences.ts
 /**
 * Gets all references to a variable that modify it (assignments, increments, decrements).
-*
-* TODO: Replace with a proper scope manager when available (see #400).
 * @returns An array of identifier nodes that modify the variable.
 */
-function getModifyingReferences(identifier, sourceFile, typeChecker) {
-	const symbol = typeChecker.getSymbolAtLocation(identifier);
-	if (!symbol?.valueDeclaration) return [];
-	const { valueDeclaration } = symbol;
-	const modifyingReferences = [];
-	function isIdentifierForSameSymbol(node) {
-		if (node.kind !== ts.SyntaxKind.Identifier) return false;
-		if (typeChecker.getSymbolAtLocation(node)?.valueDeclaration !== valueDeclaration) return false;
-		switch (node.parent.kind) {
-			case ts.SyntaxKind.BinaryExpression: return tsutils.isAssignmentKind(node.parent.operatorToken.kind) && node.parent.left === node;
-			case ts.SyntaxKind.PostfixUnaryExpression:
-			case ts.SyntaxKind.PrefixUnaryExpression: return node.parent.operand === node;
-			default: return false;
-		}
-	}
-	function visit(node) {
-		if (isIdentifierForSameSymbol(node)) modifyingReferences.push(node);
-		ts.forEachChild(node, visit);
-	}
-	visit(sourceFile);
-	return modifyingReferences;
+function getModifyingReferences(identifier, sourceFile) {
+	const variable = getScopeManager(sourceFile).findVariable(identifier);
+	if (!variable || variable.declarations.length > 1) return [];
+	return variable.references.filter((reference) => reference.isWrite).map((reference) => reference.identifier);
 }
 //#endregion
 export { getModifyingReferences };

package/lib/utils/isBuiltinArrayMethod.d.ts

@@ -10,5 +10,5 @@ type BuiltInArrayMethodNode = CallExpression & {
 };
 declare function isBuiltinArrayMethod(name: string, node: CallExpression, typeChecker: Checker): node is BuiltInArrayMethodNode;
 //#endregion
-export { isBuiltinArrayMethod };
+export { BuiltInArrayMethodNode, isBuiltinArrayMethod };
 //# sourceMappingURL=isBuiltinArrayMethod.d.ts.map

package/lib/utils/isStaticString.d.ts

@@ -0,0 +1,6 @@
+import { Expression, NoSubstitutionTemplateLiteral, StringLiteral } from "../types/ast.js";
+//#region src/utils/isStaticString.d.ts
+declare function isStaticString(node: Expression): node is NoSubstitutionTemplateLiteral | StringLiteral;
+//#endregion
+export { isStaticString };
+//# sourceMappingURL=isStaticString.d.ts.map

package/lib/utils/isStaticString.js

@@ -0,0 +1,9 @@
+import { SyntaxKind } from "typescript";
+//#region src/utils/isStaticString.ts
+function isStaticString(node) {
+	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+//#endregion
+export { isStaticString };
+
+//# sourceMappingURL=isStaticString.js.map

package/lib/utils/isStringRawNoSubstitution.d.ts

@@ -0,0 +1,8 @@
+import { Expression, NoSubstitutionTemplateLiteral, TaggedTemplateExpression } from "../types/ast.js";
+//#region src/utils/isStringRawNoSubstitution.d.ts
+declare function isStringRawNoSubstitution(node: Expression): node is TaggedTemplateExpression & {
+  template: NoSubstitutionTemplateLiteral;
+};
+//#endregion
+export { isStringRawNoSubstitution };
+//# sourceMappingURL=isStringRawNoSubstitution.d.ts.map

package/lib/utils/isStringRawNoSubstitution.js

@@ -0,0 +1,11 @@
+import { SyntaxKind } from "typescript";
+//#region src/utils/isStringRawNoSubstitution.ts
+function isStringRawNoSubstitution(node) {
+	if (node.kind !== SyntaxKind.TaggedTemplateExpression) return false;
+	const tag = node.tag;
+	return tag.kind === SyntaxKind.PropertyAccessExpression && tag.expression.kind === SyntaxKind.Identifier && tag.expression.text === "String" && tag.name.kind === SyntaxKind.Identifier && tag.name.text === "raw" && node.template.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+//#endregion
+export { isStringRawNoSubstitution };
+
+//# sourceMappingURL=isStringRawNoSubstitution.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/typescript-language",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "description": "[Experimental] TypeScript language for Flint.",
   "homepage": "https://flint.fyi",
   "repository": {
@@ -28,7 +28,7 @@
     "pathe": "^2.0.3",
     "ts-api-utils": "^2.4.0",
     "typescript": "^5.9.0 || ^6.0.0",
-    "@flint.fyi/core": "^0.22.0",
+    "@flint.fyi/core": "^0.23.0",
     "@flint.fyi/utils": "^0.14.1"
   },
   "devDependencies": {