@flint.fyi/typescript-language 0.0.0

package/lib/types/checker.d.ts

@@ -0,0 +1,23 @@
+import { CallExpression, Decorator, JsxOpeningElement, JsxSelfClosingElement, NewExpression, TaggedTemplateExpression } from "./ast.js";
+import ts, { Node, Signature, TupleTypeReference, Type, TypeChecker, TypeReference } from "typescript";
+
+//#region src/types/checker.d.ts
+type Checker = CheckerOverrides & Omit<TypeChecker, keyof CheckerOverrides>;
+interface CheckerOverrides {
+  getResolvedSignature(node: CallExpression | Decorator | JsxOpeningElement | JsxSelfClosingElement | NewExpression | TaggedTemplateExpression | ts.CallLikeExpression): Signature | undefined;
+  /** Improve narrowing, borrow from typescript-eslint */
+  isArrayType(type: Type): type is TypeReference;
+  isTupleType(type: Type): type is TupleTypeReference;
+  /**
+   * TS internal api
+   * Return the type of the given property in the given type, or undefined if no such property exists
+   */
+  getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined;
+  /**
+   * TS internal api
+   */
+  getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
+}
+//#endregion
+export { Checker };
+//# sourceMappingURL=checker.d.ts.map

package/lib/utils/declarationIncludesGlobal.d.ts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+
+//#region src/utils/declarationIncludesGlobal.d.ts
+declare function declarationIncludesGlobal(declaration: ts.Declaration): boolean;
+//#endregion
+export { declarationIncludesGlobal };
+//# sourceMappingURL=declarationIncludesGlobal.d.ts.map

package/lib/utils/declarationIncludesGlobal.js

@@ -0,0 +1,9 @@
+//#region src/utils/declarationIncludesGlobal.ts
+function declarationIncludesGlobal(declaration) {
+	const sourceFile = declaration.getSourceFile();
+	return sourceFile.hasNoDefaultLib || /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName);
+}
+
+//#endregion
+export { declarationIncludesGlobal };
+//# sourceMappingURL=declarationIncludesGlobal.js.map

package/lib/utils/declarationsIncludeGlobal.d.ts

@@ -0,0 +1,3 @@
+import type ts from "typescript";
+export declare function declarationsIncludeGlobal(declarations: ts.Declaration[]): boolean;
+//# sourceMappingURL=declarationsIncludeGlobal.d.ts.map

package/lib/utils/declarationsIncludeGlobal.js

@@ -0,0 +1,10 @@
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+
+//#region src/utils/declarationsIncludeGlobal.ts
+function declarationsIncludeGlobal(declarations) {
+	return declarations.some(declarationIncludesGlobal);
+}
+
+//#endregion
+export { declarationsIncludeGlobal };
+//# sourceMappingURL=declarationsIncludeGlobal.js.map

package/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -0,0 +1,10 @@
+import { Expression } from "../lib/types/ast.js";
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.js";
+import * as typescript0 from "typescript";
+
+//#region src/utils/getDeclarationsIfGlobal.d.ts
+declare function getDeclarationsIfGlobal(node: Expression, typeChecker: Checker): typescript0.Declaration[] | undefined;
+//#endregion
+export { getDeclarationsIfGlobal };
+//# sourceMappingURL=getDeclarationsIfGlobal.d.ts.map

package/lib/utils/getDeclarationsIfGlobal.js

@@ -0,0 +1,11 @@
+import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
+
+//#region src/utils/getDeclarationsIfGlobal.ts
+function getDeclarationsIfGlobal(node, typeChecker) {
+	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
+	return !!declarations && declarationsIncludeGlobal(declarations) ? declarations : void 0;
+}
+
+//#endregion
+export { getDeclarationsIfGlobal };
+//# sourceMappingURL=getDeclarationsIfGlobal.js.map

package/lib/utils/getModifyingReferences.d.ts

@@ -0,0 +1,17 @@
+import { Identifier, SourceFile } from "../types/ast.js";
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.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[];
+//#endregion
+export { getModifyingReferences };
+//# sourceMappingURL=getModifyingReferences.d.ts.map

package/lib/utils/getModifyingReferences.js

@@ -0,0 +1,33 @@
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+
+//#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.valueDeclaration;
+	const modifyingReferences = [];
+	function visit(node) {
+		if (ts.isIdentifier(node)) {
+			const nodeSymbol = typeChecker.getSymbolAtLocation(node);
+			if (nodeSymbol?.valueDeclaration && nodeSymbol.valueDeclaration === valueDeclaration) {
+				const parent = node.parent;
+				if (ts.isBinaryExpression(parent) && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === node) modifyingReferences.push(node);
+				else if ((ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) && parent.operand === node) modifyingReferences.push(node);
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return modifyingReferences;
+}
+
+//#endregion
+export { getModifyingReferences };
+//# sourceMappingURL=getModifyingReferences.js.map

package/lib/utils/hasSameTokens.d.ts

@@ -0,0 +1,7 @@
+import { Expression, SourceFile } from "../types/ast.js";
+
+//#region src/utils/hasSameTokens.d.ts
+declare function hasSameTokens(nodeA: Expression, nodeB: Expression, sourceFile: SourceFile): boolean;
+//#endregion
+export { hasSameTokens };
+//# sourceMappingURL=hasSameTokens.d.ts.map

package/lib/utils/hasSameTokens.js

@@ -0,0 +1,33 @@
+import { unwrapParenthesizedExpression } from "./unwrapParenthesizedExpression.js";
+import ts from "typescript";
+
+//#region src/utils/hasSameTokens.ts
+function hasSameTokens(nodeA, nodeB, sourceFile) {
+	const queueA = [unwrapParenthesizedExpression(nodeA)];
+	const queueB = [unwrapParenthesizedExpression(nodeB)];
+	while (true) {
+		const currentA = queueA.shift();
+		const currentB = queueB.shift();
+		if (!currentA || !currentB) break;
+		if (currentA.kind !== currentB.kind) return false;
+		if (ts.isTokenKind(currentA.kind)) {
+			if (!areSameToken(currentA, currentB, sourceFile)) return false;
+			continue;
+		}
+		const childrenA = currentA.getChildren(sourceFile);
+		const childrenB = currentB.getChildren(sourceFile);
+		if (childrenA.length !== childrenB.length) return false;
+		queueA.push(...childrenA);
+		queueB.push(...childrenB);
+	}
+	return queueA.length === queueB.length;
+}
+function areSameToken(nodeA, nodeB, sourceFile) {
+	if (ts.isIdentifier(nodeA) || ts.isPrivateIdentifier(nodeA) || ts.isNumericLiteral(nodeA) || ts.isBigIntLiteral(nodeA) || ts.isStringLiteral(nodeA) || ts.isNoSubstitutionTemplateLiteral(nodeA)) return nodeA.text === nodeB.text;
+	if (nodeA.kind === ts.SyntaxKind.RegularExpressionLiteral) return sourceFile.text.slice(nodeA.getStart(sourceFile), nodeA.getEnd()) === sourceFile.text.slice(nodeB.getStart(sourceFile), nodeB.getEnd());
+	return true;
+}
+
+//#endregion
+export { hasSameTokens };
+//# sourceMappingURL=hasSameTokens.js.map

package/lib/utils/isBuiltinArrayMethod.d.ts

@@ -0,0 +1,15 @@
+import { CallExpression, PropertyAccessExpression } from "../lib/types/ast.js";
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.js";
+import ts from "typescript";
+
+//#region src/utils/isBuiltinArrayMethod.d.ts
+type BuiltInArrayMethodNode = CallExpression & {
+  expression: PropertyAccessExpression & {
+    expression: ts.Expression;
+  };
+};
+declare function isBuiltinArrayMethod(name: string, node: CallExpression, typeChecker: Checker): node is BuiltInArrayMethodNode;
+//#endregion
+export { isBuiltinArrayMethod };
+//# sourceMappingURL=isBuiltinArrayMethod.d.ts.map

package/lib/utils/isBuiltinArrayMethod.js

@@ -0,0 +1,10 @@
+import ts from "typescript";
+
+//#region src/utils/isBuiltinArrayMethod.ts
+function isBuiltinArrayMethod(name, node, typeChecker) {
+	return ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === name && typeChecker.isArrayType(typeChecker.getTypeAtLocation(node.expression.expression)) && !ts.isExpressionStatement(node.parent);
+}
+
+//#endregion
+export { isBuiltinArrayMethod };
+//# sourceMappingURL=isBuiltinArrayMethod.js.map

package/lib/utils/isFunction.d.ts

@@ -0,0 +1,9 @@
+import { Expression } from "../lib/types/ast.js";
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.js";
+
+//#region src/utils/isFunction.d.ts
+declare function isFunction(node: Expression, typeChecker: Checker): boolean;
+//#endregion
+export { isFunction };
+//# sourceMappingURL=isFunction.d.ts.map

package/lib/utils/isFunction.js

@@ -0,0 +1,8 @@
+//#region src/utils/isFunction.ts
+function isFunction(node, typeChecker) {
+	return !!typeChecker.getTypeAtLocation(node).getCallSignatures().length;
+}
+
+//#endregion
+export { isFunction };
+//# sourceMappingURL=isFunction.js.map

package/lib/utils/isGlobalDeclaration.d.ts

@@ -0,0 +1,9 @@
+import { Expression } from "../lib/types/ast.js";
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.js";
+
+//#region src/utils/isGlobalDeclaration.d.ts
+declare function isGlobalDeclaration(node: Expression, typeChecker: Checker): boolean;
+//#endregion
+export { isGlobalDeclaration };
+//# sourceMappingURL=isGlobalDeclaration.d.ts.map

package/lib/utils/isGlobalDeclaration.js

@@ -0,0 +1,10 @@
+import { getDeclarationsIfGlobal } from "./getDeclarationsIfGlobal.js";
+
+//#region src/utils/isGlobalDeclaration.ts
+function isGlobalDeclaration(node, typeChecker) {
+	return !!getDeclarationsIfGlobal(node, typeChecker);
+}
+
+//#endregion
+export { isGlobalDeclaration };
+//# sourceMappingURL=isGlobalDeclaration.js.map

package/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -0,0 +1,12 @@
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.js";
+import ts from "typescript";
+
+//#region src/utils/isGlobalDeclarationOfName.d.ts
+/**
+ * TODO: Use a scope analyzer (#400).
+ */
+declare function isGlobalDeclarationOfName(node: ts.Node, name: string, typeChecker: Checker): boolean;
+//#endregion
+export { isGlobalDeclarationOfName };
+//# sourceMappingURL=isGlobalDeclarationOfName.d.ts.map

package/lib/utils/isGlobalDeclarationOfName.js

@@ -0,0 +1,24 @@
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+import ts from "typescript";
+
+//#region src/utils/isGlobalDeclarationOfName.ts
+/**
+* TODO: Use a scope analyzer (#400).
+*/
+function isGlobalDeclarationOfName(node, name, typeChecker) {
+	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
+	if (!declarations) return false;
+	return declarations.every((declaration) => {
+		if (ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isIdentifier(declaration.initializer)) return isGlobalDeclarationOfName(declaration.initializer, name, typeChecker);
+		if (ts.isPropertySignature(declaration)) return isGlobalDeclarationOfName(declaration.parent, name, typeChecker);
+		return isDeclarationOfName(declaration, name) && declarationIncludesGlobal(declaration);
+	});
+}
+function isDeclarationOfName(node, name) {
+	if (ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isVariableDeclaration(node)) return node.name && ts.isIdentifier(node.name) && node.name.text === name;
+	return false;
+}
+
+//#endregion
+export { isGlobalDeclarationOfName };
+//# sourceMappingURL=isGlobalDeclarationOfName.js.map

package/lib/utils/isGlobalVariable.d.ts

@@ -0,0 +1,16 @@
+import { Expression } from "../lib/types/ast.js";
+import { Checker } from "../lib/types/checker.js";
+import "../lib/index.js";
+
+//#region src/utils/isGlobalVariable.d.ts
+
+/**
+ * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
+ * Global variables are those declared in TypeScript's lib files or are global identifiers
+ * like undefined which have symbols but no user-defined declarations.
+ * TODO: Use a scope manager (#400).
+ */
+declare function isGlobalVariable(node: Expression, typeChecker: Checker): boolean;
+//#endregion
+export { isGlobalVariable };
+//# sourceMappingURL=isGlobalVariable.d.ts.map

package/lib/utils/isGlobalVariable.js

@@ -0,0 +1,20 @@
+import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
+
+//#region src/utils/isGlobalVariable.ts
+/**
+* Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
+* Global variables are those declared in TypeScript's lib files or are global identifiers
+* like undefined which have symbols but no user-defined declarations.
+* TODO: Use a scope manager (#400).
+*/
+function isGlobalVariable(node, typeChecker) {
+	const symbol = typeChecker.getSymbolAtLocation(node);
+	if (!symbol) return false;
+	const declarations = symbol.getDeclarations();
+	if (!declarations?.length) return true;
+	return declarationsIncludeGlobal(declarations);
+}
+
+//#endregion
+export { isGlobalVariable };
+//# sourceMappingURL=isGlobalVariable.js.map

package/lib/utils/isInlineArrayCreation.d.ts

@@ -0,0 +1,13 @@
+import * as ts$1 from "typescript";
+
+//#region src/utils/isInlineArrayCreation.d.ts
+
+/**
+ * Checks if a node represents an inline array creation expression.
+ * These are cases where a new array is created immediately before the method call,
+ * so mutating methods like .sort() or .reverse() are safe to use.
+ */
+declare function isInlineArrayCreation(node: ts$1.Expression): boolean;
+//#endregion
+export { isInlineArrayCreation };
+//# sourceMappingURL=isInlineArrayCreation.d.ts.map

package/lib/utils/isInlineArrayCreation.js

@@ -0,0 +1,46 @@
+import * as ts$1 from "typescript";
+
+//#region src/utils/isInlineArrayCreation.ts
+const methodsReturningNewArray = new Set([
+	"concat",
+	"entries",
+	"filter",
+	"flat",
+	"flatMap",
+	"from",
+	"keys",
+	"map",
+	"of",
+	"slice",
+	"split",
+	"values"
+]);
+const objectStaticMethods = new Set([
+	"entries",
+	"keys",
+	"values"
+]);
+/**
+* Checks if a node represents an inline array creation expression.
+* These are cases where a new array is created immediately before the method call,
+* so mutating methods like .sort() or .reverse() are safe to use.
+*/
+function isInlineArrayCreation(node) {
+	if (ts$1.isArrayLiteralExpression(node)) return true;
+	if (ts$1.isParenthesizedExpression(node)) return isInlineArrayCreation(node.expression);
+	if (ts$1.isCallExpression(node)) {
+		if (ts$1.isPropertyAccessExpression(node.expression)) {
+			const methodName = node.expression.name.text;
+			if (ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && objectStaticMethods.has(methodName)) return true;
+			if (ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "Array" && (methodName === "from" || methodName === "of")) return true;
+			if (methodsReturningNewArray.has(methodName)) return true;
+		}
+		if (ts$1.isIdentifier(node.expression) && node.expression.text === "Array" && ts$1.isNewExpression(node.parent)) return true;
+	}
+	if (ts$1.isNewExpression(node) && ts$1.isIdentifier(node.expression) && node.expression.text === "Array") return true;
+	return false;
+}
+
+//#endregion
+export { isInlineArrayCreation };
+//# sourceMappingURL=isInlineArrayCreation.js.map

package/lib/utils/unwrapParentParenthesizedExpressions.d.ts

@@ -0,0 +1,7 @@
+import { BinaryExpression, LeftHandSideExpressionParent, ParenthesizedExpression } from "../types/ast.js";
+
+//#region src/utils/unwrapParentParenthesizedExpressions.d.ts
+declare function unwrapParenthesizedExpressionsParent(node: BinaryExpression | ParenthesizedExpression): LeftHandSideExpressionParent;
+//#endregion
+export { unwrapParenthesizedExpressionsParent };
+//# sourceMappingURL=unwrapParentParenthesizedExpressions.d.ts.map

package/lib/utils/unwrapParentParenthesizedExpressions.js

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "typescript";
+
+//#region src/utils/unwrapParentParenthesizedExpressions.ts
+function unwrapParenthesizedExpressionsParent(node) {
+	return node.parent.kind === SyntaxKind.ParenthesizedExpression ? unwrapParenthesizedExpressionsParent(node.parent) : node.parent;
+}
+
+//#endregion
+export { unwrapParenthesizedExpressionsParent };
+//# sourceMappingURL=unwrapParentParenthesizedExpressions.js.map

package/lib/utils/unwrapParenthesizedExpression.d.ts

@@ -0,0 +1,7 @@
+import { ConciseBody, Expression } from "../types/ast.js";
+
+//#region src/utils/unwrapParenthesizedExpression.d.ts
+declare function unwrapParenthesizedExpression(expression: ConciseBody | Expression): ConciseBody | Expression;
+//#endregion
+export { unwrapParenthesizedExpression };
+//# sourceMappingURL=unwrapParenthesizedExpression.d.ts.map

package/lib/utils/unwrapParenthesizedExpression.js

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "typescript";
+
+//#region src/utils/unwrapParenthesizedExpression.ts
+function unwrapParenthesizedExpression(expression) {
+	return expression.kind === SyntaxKind.ParenthesizedExpression ? unwrapParenthesizedExpression(expression.expression) : expression;
+}
+
+//#endregion
+export { unwrapParenthesizedExpression };
+//# sourceMappingURL=unwrapParenthesizedExpression.js.map

package/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "@flint.fyi/typescript-language",
+	"version": "0.0.0",
+	"description": "[Experimental] TypeScript language for Flint.",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/flint-fyi/flint.git",
+		"directory": "packages/typescript-language"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "JoshuaKGoldberg",
+		"email": "npm@joshuakgoldberg.com"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"@flint.fyi/source": "./src/index.ts",
+			"default": "./lib/index.js"
+		}
+	},
+	"files": [
+		"lib/",
+		"!lib/**/*.map"
+	],
+	"scripts": {
+		"test": "vitest --typecheck --project typescript-language"
+	},
+	"dependencies": {
+		"@flint.fyi/core": "workspace:^",
+		"@flint.fyi/utils": "workspace:^",
+		"@typescript-eslint/project-service": "^8.46.2",
+		"@typescript/vfs": "^1.6.1",
+		"cached-factory": "^0.1.0",
+		"debug-for-file": "^0.2.0",
+		"ts-api-utils": "^2.1.0",
+		"typescript": "^5.9.0 || ^6.0.0"
+	},
+	"devDependencies": {
+		"tsdown": "0.19.0-beta.2",
+		"vitest": "4.0.15"
+	},
+	"engines": {
+		"node": ">=24.0.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"exports": {
+			".": "./lib/index.js"
+		}
+	}
+}