@flint.fyi/typescript-language 0.0.0 → 0.18.1

package/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/lib/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/lib/collectReferencedFilePaths.js

@@ -1,8 +1,7 @@
 import ts from "typescript";
 import { nullThrows } from "@flint.fyi/utils";
-import * as path$1 from "node:path";
 import * as tsutils from "ts-api-utils";
-
+import * as path$1 from "node:path";
 //#region src/collectReferencedFilePaths.ts
 function collectReferencedFilePaths(program, sourceFile) {
 	const modulePaths = /* @__PURE__ */ new Set();
@@ -11,12 +10,12 @@ function collectReferencedFilePaths(program, sourceFile) {
 		if (resolved.resolvedModule?.isExternalLibraryImport === false) return path$1.relative(process.cwd(), resolved.resolvedModule.resolvedFileName);
 	}
 	function visit(node) {
-		let path$2;
-		if (isImportDeclaration(node)) path$2 = node.moduleSpecifier.text;
-		else if (isImportCall(node)) path$2 = node.arguments[0].text;
-		else if (isAwaitImportCall(node)) path$2 = node.expression.arguments[0].text;
-		else if (isImportTypeNode(node)) path$2 = node.argument.literal.text;
-		const resolvedPath = path$2 && resolveModulePath(path$2);
+		let path;
+		if (isImportDeclaration(node)) path = node.moduleSpecifier.text;
+		else if (isImportCall(node)) path = node.arguments[0].text;
+		else if (isAwaitImportCall(node)) path = node.expression.arguments[0].text;
+		else if (isImportTypeNode(node)) path = node.argument.literal.text;
+		const resolvedPath = path && resolveModulePath(path);
 		if (resolvedPath) modulePaths.add(resolvedPath);
 		ts.forEachChild(node, visit);
 	}
@@ -27,7 +26,7 @@ function isAwaitImportCall(node) {
 	return ts.isAwaitExpression(node) && isImportCall(node.expression);
 }
 function isImportCall(node) {
-	return ts.isCallExpression(node) && tsutils.isImportExpression(node.expression) && node.arguments.length > 0 && ts.isStringLiteral(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
+	return ts.isCallExpression(node) && tsutils.isImportExpression(node.expression) && !!node.arguments.length && ts.isStringLiteral(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
 }
 function isImportDeclaration(node) {
 	return ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier);
@@ -35,7 +34,7 @@ function isImportDeclaration(node) {
 function isImportTypeNode(node) {
 	return ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal);
 }
-
 //#endregion
 export { collectReferencedFilePaths };
+
 //# sourceMappingURL=collectReferencedFilePaths.js.map

package/lib/convertTypeScriptDiagnosticToLanguageReport.d.ts

@@ -0,0 +1,18 @@
+import { LanguageReport, SourceFileWithLineMapAndFileName } from "@flint.fyi/core";
+import ts from "typescript";
+
+//#region src/convertTypeScriptDiagnosticToLanguageReport.d.ts
+interface TSDiagnostic extends TSDiagnosticRelatedInformation {
+  relatedInformation?: TSDiagnosticRelatedInformation[];
+}
+interface TSDiagnosticRelatedInformation {
+  code: number;
+  file: SourceFileWithLineMapAndFileName | undefined;
+  length: number | undefined;
+  messageText: string | ts.DiagnosticMessageChain;
+  start: number | undefined;
+}
+declare function convertTypeScriptDiagnosticToLanguageReport(diagnostic: TSDiagnostic): LanguageReport;
+//#endregion
+export { convertTypeScriptDiagnosticToLanguageReport };
+//# sourceMappingURL=convertTypeScriptDiagnosticToLanguageReport.d.ts.map

package/lib/{convertTypeScriptDiagnosticToLanguageFileDiagnostic.js → convertTypeScriptDiagnosticToLanguageReport.js}

@@ -1,17 +1,20 @@
 import { getColumnAndLineOfPosition, getPositionOfColumnAndLine } from "@flint.fyi/core";
-import ts, { flattenDiagnosticMessageText } from "typescript";
-
-//#region src/convertTypeScriptDiagnosticToLanguageFileDiagnostic.ts
-function convertTypeScriptDiagnosticToLanguageFileDiagnostic(diagnostic) {
+import ts from "typescript";
+//#region src/convertTypeScriptDiagnosticToLanguageReport.ts
+function convertTypeScriptDiagnosticToLanguageReport(diagnostic) {
 	return {
 		code: `TS${diagnostic.code}`,
-		text: formatDiagnostic(diagnostic)
+		text: formatReport(diagnostic),
+		...diagnostic.file !== void 0 && diagnostic.start !== void 0 && { range: {
+			begin: diagnostic.start,
+			end: diagnostic.start + (diagnostic.length ?? 0)
+		} }
 	};
 }
 function color(text, formatStyle) {
 	return formatStyle + text + resetEscapeSequence;
 }
-function formatDiagnostic(diagnostic) {
+function formatReport(diagnostic) {
 	let output = "";
 	if (diagnostic.file !== void 0) {
 		output += formatLocation(diagnostic.file, diagnostic.start);
@@ -34,7 +37,7 @@ function formatDiagnostic(diagnostic) {
 				output += formatCodeSpan(file, start, length, indent, COLOR.Cyan);
 			}
 			output += "\n";
-			output += indent + flattenDiagnosticMessageText(messageText, "\n");
+			output += indent + ts.flattenDiagnosticMessageText(messageText, "\n");
 		}
 	}
 	return output;
@@ -104,7 +107,7 @@ function formatLocation(file, start) {
 	output += color(`${column + 1}`, COLOR.Yellow);
 	return output;
 }
-
 //#endregion
-export { convertTypeScriptDiagnosticToLanguageFileDiagnostic };
-//# sourceMappingURL=convertTypeScriptDiagnosticToLanguageFileDiagnostic.js.map
+export { convertTypeScriptDiagnosticToLanguageReport };
+
+//# sourceMappingURL=convertTypeScriptDiagnosticToLanguageReport.js.map

package/lib/createTypeScriptServerHost.d.ts

@@ -0,0 +1,4 @@
+import type { LinterHost } from "@flint.fyi/core";
+import ts from "typescript";
+export declare function createTypeScriptServerHost(host: LinterHost): ts.server.ServerHost;
+//# sourceMappingURL=createTypeScriptServerHost.d.ts.map

package/lib/createTypeScriptServerHost.js

@@ -0,0 +1,99 @@
+import ts from "typescript";
+import { FlintAssertionError, assert } from "@flint.fyi/utils";
+import path from "node:path";
+import fs from "node:fs";
+import timers from "node:timers";
+//#region src/createTypeScriptServerHost.ts
+function serverHostMethodNotImplemented(methodName) {
+	throw new FlintAssertionError(`ts.ServerHost's method '${methodName}' is not implemented.`);
+}
+const UV_DIRENT_TYPE = {
+	UV_DIRENT_DIR: 2,
+	UV_DIRENT_FILE: 1
+};
+const DirentCtor = fs.Dirent;
+function createTypeScriptServerHost(host) {
+	return {
+		...ts.sys,
+		args: [],
+		clearImmediate: timers.clearImmediate,
+		clearTimeout: timers.clearTimeout,
+		createDirectory() {
+			serverHostMethodNotImplemented("createDirectory");
+		},
+		directoryExists(directoryPath) {
+			return host.fileTypeSync(path.resolve(host.getCurrentDirectory(), directoryPath)) === "directory";
+		},
+		exit() {
+			serverHostMethodNotImplemented("exit");
+		},
+		fileExists(filePath) {
+			return host.fileTypeSync(path.resolve(host.getCurrentDirectory(), filePath)) === "file";
+		},
+		readDirectory(directoryPath, extensions, exclude, include, depth) {
+			const originalCwd = process.cwd.bind(process);
+			process.cwd = () => host.getCurrentDirectory();
+			const originalReadDirSync = fs.readdirSync;
+			const patchedReaddirSync = (readPath, options) => {
+				assert(typeof options === "object" && options != null && Object.keys(options).length === 1 && options.withFileTypes === true, `ts.sys.readDirectory passed unexpected options to fs.readdirSync: ${JSON.stringify(options)}`);
+				assert(typeof readPath === "string", "ts.sys.readDirectory passed unexpected path to fs.readdirSync");
+				try {
+					fs.readdirSync = originalReadDirSync;
+					return host.readDirectorySync(path.resolve(host.getCurrentDirectory(), readPath)).map((dirent) => new DirentCtor(dirent.name, dirent.type === "file" ? UV_DIRENT_TYPE.UV_DIRENT_FILE : UV_DIRENT_TYPE.UV_DIRENT_DIR, readPath));
+				} finally {
+					fs.readdirSync = patchedReaddirSync;
+				}
+			};
+			fs.readdirSync = patchedReaddirSync;
+			try {
+				return ts.sys.readDirectory(directoryPath, extensions, exclude, include, depth);
+			} finally {
+				process.cwd = originalCwd;
+				fs.readdirSync = originalReadDirSync;
+			}
+		},
+		readFile(filePath) {
+			return host.readFileSync(path.resolve(host.getCurrentDirectory(), filePath));
+		},
+		setImmediate: timers.setImmediate,
+		setTimeout: timers.setTimeout,
+		watchDirectory(directoryPath, callback, recursive = false) {
+			const watcher = host.watchDirectorySync(path.resolve(host.getCurrentDirectory(), directoryPath), (filePathAbsolute) => {
+				callback(filePathAbsolute);
+			}, { recursive });
+			return { close() {
+				watcher[Symbol.dispose]();
+			} };
+		},
+		watchFile(filePath, callback) {
+			const watcher = host.watchFileSync(path.resolve(host.getCurrentDirectory(), filePath), (event) => {
+				let eventKind;
+				switch (event) {
+					case "changed":
+						eventKind = ts.FileWatcherEventKind.Changed;
+						break;
+					case "created":
+						eventKind = ts.FileWatcherEventKind.Created;
+						break;
+					case "deleted":
+						eventKind = ts.FileWatcherEventKind.Deleted;
+						break;
+				}
+				callback(filePath, eventKind);
+			});
+			return { close() {
+				watcher[Symbol.dispose]();
+			} };
+		},
+		write() {
+			serverHostMethodNotImplemented("write");
+		},
+		writeFile() {
+			serverHostMethodNotImplemented("writeFile");
+		}
+	};
+}
+//#endregion
+export { createTypeScriptServerHost };
+
+//# sourceMappingURL=createTypeScriptServerHost.js.map

package/lib/directives/parseDirectivesFromTypeScriptFile.js

@@ -1,8 +1,8 @@
 import { normalizeRange } from "../normalizeRange.js";
 import { DirectivesCollector } from "@flint.fyi/core";
+import ts from "typescript";
 import { nullThrows } from "@flint.fyi/utils";
 import * as tsutils from "ts-api-utils";
-
 //#region src/directives/parseDirectivesFromTypeScriptFile.ts
 function extractDirectivesFromTypeScriptFile(sourceFile) {
 	const directives = [];
@@ -10,13 +10,14 @@ function extractDirectivesFromTypeScriptFile(sourceFile) {
 		const commentText = fullText.slice(sourceRange.pos, sourceRange.end);
 		const match = /^\/\/\s*flint-(\S+)(?:\s+(.+))?/.exec(commentText);
 		if (!match) return;
-		const range = normalizeRange({
+		let range = normalizeRange({
 			begin: sourceRange.pos,
 			end: sourceRange.end
 		}, sourceFile);
 		const matches = match.slice(1);
 		const type = nullThrows(matches[0], "First match is expected to be present by the regex match");
 		const selection = matches[1] ?? "";
+		if (type === "disable-next-line") range = extendRangeToNextCodeLine(sourceFile, range);
 		directives.push({
 			range,
 			selection,
@@ -30,7 +31,36 @@ function parseDirectivesFromTypeScriptFile(sourceFile) {
 	for (const { range, selection, type } of extractDirectivesFromTypeScriptFile(sourceFile)) collector.add(range, selection, type);
 	return collector.collect();
 }
-
+function computeNextCodeLine(sourceFile, directiveLine) {
+	const lineStarts = sourceFile.getLineStarts();
+	const nextLineStart = lineStarts[directiveLine + 1];
+	if (nextLineStart === void 0) return;
+	const scanner = ts.createScanner(sourceFile.languageVersion, true, sourceFile.languageVariant, sourceFile.text, void 0, nextLineStart);
+	if (scanner.scan() === ts.SyntaxKind.EndOfFileToken) return;
+	const tokenPos = scanner.getTokenStart();
+	const codeLine = sourceFile.getLineAndCharacterOfPosition(tokenPos).line;
+	for (let line = directiveLine + 1; line < codeLine; line++) {
+		const start = lineStarts[line];
+		const end = lineStarts[line + 1] ?? sourceFile.text.length;
+		if (sourceFile.text.slice(start, end).trim() === "") return;
+	}
+	return codeLine;
+}
+function extendRangeToNextCodeLine(sourceFile, range) {
+	const codeLine = computeNextCodeLine(sourceFile, range.begin.line);
+	if (codeLine === void 0 || codeLine <= range.end.line + 1) return range;
+	const endPosition = nullThrows(sourceFile.getLineStarts()[codeLine], "Code line start is expected to be present by the computed code line") - 1;
+	const { character, line } = sourceFile.getLineAndCharacterOfPosition(endPosition);
+	return {
+		...range,
+		end: {
+			column: character,
+			line,
+			raw: endPosition
+		}
+	};
+}
 //#endregion
 export { extractDirectivesFromTypeScriptFile, parseDirectivesFromTypeScriptFile };
+
 //# sourceMappingURL=parseDirectivesFromTypeScriptFile.js.map

package/lib/getFirstEnumValues.js

@@ -42,7 +42,7 @@ function getFirstEnumValues(original) {
 	}
 	return result;
 }
-
 //#endregion
 export { getFirstEnumValues };
+
 //# sourceMappingURL=getFirstEnumValues.js.map

package/lib/getTSNodeRange.js

@@ -5,7 +5,7 @@ function getTSNodeRange(node, sourceFile) {
 		end: node.getEnd()
 	};
 }
-
 //#endregion
 export { getTSNodeRange };
+
 //# sourceMappingURL=getTSNodeRange.js.map

package/lib/getTypeScriptFileCacheImpacts.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageFile, LanguageFileCacheImpacts } from "@flint.fyi/core";
+import type { TypeScriptFileServices } from "./language.ts";
+export declare function getTypeScriptFileCacheImpacts(file: LanguageFile<TypeScriptFileServices>): LanguageFileCacheImpacts;
+//# sourceMappingURL=getTypeScriptFileCacheImpacts.d.ts.map

package/lib/getTypeScriptFileCacheImpacts.js

@@ -0,0 +1,9 @@
+import { collectReferencedFilePaths } from "./collectReferencedFilePaths.js";
+//#region src/getTypeScriptFileCacheImpacts.ts
+function getTypeScriptFileCacheImpacts(file) {
+	return { dependencies: ["tsconfig.json", ...collectReferencedFilePaths(file.services.program, file.services.sourceFile)] };
+}
+//#endregion
+export { getTypeScriptFileCacheImpacts };
+
+//# sourceMappingURL=getTypeScriptFileCacheImpacts.js.map

package/lib/index.d.ts

@@ -1,12 +1,11 @@
-import { convertTypeScriptDiagnosticToLanguageFileDiagnostic } from "./convertTypeScriptDiagnosticToLanguageFileDiagnostic.js";
+import { convertTypeScriptDiagnosticToLanguageReport } from "./convertTypeScriptDiagnosticToLanguageReport.js";
 import { ast_d_exports } from "./types/ast.js";
-import { TypeScriptNodesByName } from "./nodes.js";
-import { Checker } from "./types/checker.js";
-import { TypeScriptFileServices, typescriptLanguage } from "./language.js";
-import { NodeSyntaxKinds, collectTypeScriptFileCacheImpacts } from "./createTypeScriptFileFromProgram.js";
 import { ExtractedDirective, extractDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
 import { getTSNodeRange } from "./getTSNodeRange.js";
-import { TypeScriptBasedLanguageFile, TypeScriptBasedLanguageFileFactoryDefinition, prepareTypeScriptBasedLanguage } from "./prepareTypeScriptBasedLanguage.js";
+import { TypeScriptNodeVisitors, TypeScriptNodesByName } from "./nodes.js";
+import { Checker } from "./types/checker.js";
+import { NodeSyntaxKinds, TypeScriptFileServices, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage } from "./language.js";
+import { createRuleTesterTSConfig } from "./utils/createRuleTesterTSConfig.js";
 import { declarationIncludesGlobal } from "./utils/declarationIncludesGlobal.js";
 import { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 import { getModifyingReferences } from "./utils/getModifyingReferences.js";
@@ -17,6 +16,6 @@ import { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
 import { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
 import { isGlobalVariable } from "./utils/isGlobalVariable.js";
 import { isInlineArrayCreation } from "./utils/isInlineArrayCreation.js";
-import { unwrapParenthesizedExpression } from "./utils/unwrapParenthesizedExpression.js";
-import { unwrapParenthesizedExpressionsParent } from "./utils/unwrapParentParenthesizedExpressions.js";
-export { type ast_d_exports as AST, type Checker, type ExtractedDirective, NodeSyntaxKinds, type TypeScriptBasedLanguageFile, type TypeScriptBasedLanguageFileFactoryDefinition, TypeScriptFileServices, type TypeScriptNodesByName, collectTypeScriptFileCacheImpacts, convertTypeScriptDiagnosticToLanguageFileDiagnostic, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, getDeclarationsIfGlobal, getModifyingReferences, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, prepareTypeScriptBasedLanguage, typescriptLanguage, unwrapParenthesizedExpression, unwrapParenthesizedExpressionsParent };
+import { unwrapParenthesizedNode } from "./utils/unwrapParenthesizedNode.js";
+import { unwrapParentParenthesizedExpressions } from "./utils/unwrapParentParenthesizedExpressions.js";
+export { type ast_d_exports as AST, type Checker, type ExtractedDirective, NodeSyntaxKinds, TypeScriptFileServices, TypeScriptNodeVisitors, type TypeScriptNodesByName, convertTypeScriptDiagnosticToLanguageReport, createRuleTesterTSConfig, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, getDeclarationsIfGlobal, getModifyingReferences, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode };

package/lib/index.js

@@ -1,13 +1,12 @@
-import { convertTypeScriptDiagnosticToLanguageFileDiagnostic } from "./convertTypeScriptDiagnosticToLanguageFileDiagnostic.js";
-import { NodeSyntaxKinds, collectTypeScriptFileCacheImpacts } from "./createTypeScriptFileFromProgram.js";
+import { convertTypeScriptDiagnosticToLanguageReport } from "./convertTypeScriptDiagnosticToLanguageReport.js";
 import { extractDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
 import { getTSNodeRange } from "./getTSNodeRange.js";
-import { prepareTypeScriptBasedLanguage } from "./prepareTypeScriptBasedLanguage.js";
-import { typescriptLanguage } from "./language.js";
+import { NodeSyntaxKinds, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage } from "./language.js";
+import { createRuleTesterTSConfig } from "./utils/createRuleTesterTSConfig.js";
 import { declarationIncludesGlobal } from "./utils/declarationIncludesGlobal.js";
 import { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 import { getModifyingReferences } from "./utils/getModifyingReferences.js";
-import { unwrapParenthesizedExpression } from "./utils/unwrapParenthesizedExpression.js";
+import { unwrapParenthesizedNode } from "./utils/unwrapParenthesizedNode.js";
 import { hasSameTokens } from "./utils/hasSameTokens.js";
 import { isBuiltinArrayMethod } from "./utils/isBuiltinArrayMethod.js";
 import { isFunction } from "./utils/isFunction.js";
@@ -15,6 +14,5 @@ import { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
 import { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
 import { isGlobalVariable } from "./utils/isGlobalVariable.js";
 import { isInlineArrayCreation } from "./utils/isInlineArrayCreation.js";
-import { unwrapParenthesizedExpressionsParent } from "./utils/unwrapParentParenthesizedExpressions.js";
-
-export { NodeSyntaxKinds, collectTypeScriptFileCacheImpacts, convertTypeScriptDiagnosticToLanguageFileDiagnostic, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, getDeclarationsIfGlobal, getModifyingReferences, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, prepareTypeScriptBasedLanguage, typescriptLanguage, unwrapParenthesizedExpression, unwrapParenthesizedExpressionsParent };
+import { unwrapParentParenthesizedExpressions } from "./utils/unwrapParentParenthesizedExpressions.js";
+export { NodeSyntaxKinds, convertTypeScriptDiagnosticToLanguageReport, createRuleTesterTSConfig, declarationIncludesGlobal, extractDirectivesFromTypeScriptFile, getDeclarationsIfGlobal, getModifyingReferences, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode };

package/lib/language.d.ts

@@ -1,7 +1,8 @@
-import { SourceFile } from "./types/ast.js";
-import { TypeScriptNodesByName } from "./nodes.js";
+import { AnyKeyword, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntKeyword, BigIntLiteral, BinaryExpression, BindingElement, Block, BooleanKeyword, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, CommaListExpression, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DefaultClause, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, FalseLiteral, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportExpression, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, IntrinsicKeyword, JSDocAllType, JSDocFunctionType, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocMemberName, JSDocNamepathType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterTag, JSDocPropertyTag, JSDocReturnTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocTypeExpression, JSDocTypeLiteral, JSDocUnknownType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignature, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NeverKeyword, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NotEmittedStatement, NotEmittedTypeElement, NullLiteral, NumberKeyword, NumericLiteral, ObjectBindingPattern, ObjectKeyword, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignature, QualifiedName, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringKeyword, StringLiteral, SuperExpression, SwitchStatement, SymbolKeyword, SyntheticExpression, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisExpression, ThisTypeNode, ThrowStatement, TrueLiteral, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UndefinedKeyword, UnionTypeNode, UnknownKeyword, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, VoidKeyword, WhileStatement, WithStatement, YieldExpression } from "./types/ast.js";
+import { TypeScriptNodeVisitors, TypeScriptNodesByName } from "./nodes.js";
 import { Checker } from "./types/checker.js";
-import * as _flint_fyi_core1 from "@flint.fyi/core";
+import * as _flint_fyi_core0 from "@flint.fyi/core";
+import { AnyOptionalSchema, FileAboutData, InferredOutputObject, LanguageFile, LanguageFileDefinition, LanguageReports, RuleRuntime } from "@flint.fyi/core";
 import * as ts$1 from "typescript";
 
 //#region src/language.d.ts
@@ -10,7 +11,212 @@ interface TypeScriptFileServices {
   sourceFile: SourceFile;
   typeChecker: Checker;
 }
-declare const typescriptLanguage: _flint_fyi_core1.Language<TypeScriptNodesByName, TypeScriptFileServices>;
+declare const NodeSyntaxKinds: typeof ts$1.SyntaxKind;
+type VolarCreateFile = (data: FileAboutData, program: ts$1.Program, sourceFile: SourceFile) => VolarLanguageFileDefinition;
+type VolarLanguageFileDefinition = LanguageFileDefinition<object> & {
+  __volarServices: {
+    getLanguageReports(): LanguageReports;
+    runVisitors(file: LanguageFile<TypeScriptFileServices>, options: InferredOutputObject<AnyOptionalSchema | undefined>, runtime: RuleRuntime<TypeScriptNodeVisitors, TypeScriptFileServices>): void;
+  };
+};
+declare function setVolarCreateFile(create: VolarCreateFile): void;
+declare const typescriptLanguage: _flint_fyi_core0.Language<_flint_fyi_core0.Simplify<TypeScriptNodesByName & {
+  "AnyKeyword:exit"?: AnyKeyword;
+  "ArrayBindingPattern:exit"?: ArrayBindingPattern;
+  "ArrayLiteralExpression:exit"?: ArrayLiteralExpression;
+  "ArrayType:exit"?: ArrayTypeNode;
+  "ArrowFunction:exit"?: ArrowFunction;
+  "AsExpression:exit"?: AsExpression;
+  "AwaitExpression:exit"?: AwaitExpression;
+  "BigIntKeyword:exit"?: BigIntKeyword;
+  "BigIntLiteral:exit"?: BigIntLiteral;
+  "BinaryExpression:exit"?: BinaryExpression;
+  "BindingElement:exit"?: BindingElement;
+  "Block:exit"?: Block;
+  "BooleanKeyword:exit"?: BooleanKeyword;
+  "BreakStatement:exit"?: BreakStatement;
+  "CallExpression:exit"?: CallExpression;
+  "CallSignature:exit"?: CallSignatureDeclaration;
+  "CaseBlock:exit"?: CaseBlock;
+  "CaseClause:exit"?: CaseClause;
+  "CatchClause:exit"?: CatchClause;
+  "ClassDeclaration:exit"?: ClassDeclaration;
+  "ClassExpression:exit"?: ClassExpression;
+  "ClassStaticBlockDeclaration:exit"?: ClassStaticBlockDeclaration;
+  "CommaListExpression:exit"?: CommaListExpression;
+  "ComputedPropertyName:exit"?: ComputedPropertyName;
+  "ConditionalExpression:exit"?: ConditionalExpression;
+  "ConditionalType:exit"?: ConditionalTypeNode;
+  "Constructor:exit"?: ConstructorDeclaration;
+  "ConstructorType:exit"?: ConstructorTypeNode;
+  "ConstructSignature:exit"?: ConstructSignatureDeclaration;
+  "ContinueStatement:exit"?: ContinueStatement;
+  "DebuggerStatement:exit"?: DebuggerStatement;
+  "Decorator:exit"?: Decorator;
+  "DefaultClause:exit"?: DefaultClause;
+  "DeleteExpression:exit"?: DeleteExpression;
+  "DoStatement:exit"?: DoStatement;
+  "ElementAccessExpression:exit"?: ElementAccessExpression;
+  "EmptyStatement:exit"?: EmptyStatement;
+  "EnumDeclaration:exit"?: EnumDeclaration;
+  "EnumMember:exit"?: EnumMember;
+  "ExportAssignment:exit"?: ExportAssignment;
+  "ExportDeclaration:exit"?: ExportDeclaration;
+  "ExportSpecifier:exit"?: ExportSpecifier;
+  "ExpressionStatement:exit"?: ExpressionStatement;
+  "ExpressionWithTypeArguments:exit"?: ExpressionWithTypeArguments;
+  "ExternalModuleReference:exit"?: ExternalModuleReference;
+  "FalseKeyword:exit"?: FalseLiteral;
+  "ForInStatement:exit"?: ForInStatement;
+  "ForOfStatement:exit"?: ForOfStatement;
+  "ForStatement:exit"?: ForStatement;
+  "FunctionDeclaration:exit"?: FunctionDeclaration;
+  "FunctionExpression:exit"?: FunctionExpression;
+  "FunctionType:exit"?: FunctionTypeNode;
+  "GetAccessor:exit"?: GetAccessorDeclaration;
+  "HeritageClause:exit"?: HeritageClause;
+  "Identifier:exit"?: Identifier;
+  "IfStatement:exit"?: IfStatement;
+  "ImportAttribute:exit"?: ImportAttribute;
+  "ImportAttributes:exit"?: ImportAttributes;
+  "ImportClause:exit"?: ImportClause;
+  "ImportDeclaration:exit"?: ImportDeclaration;
+  "ImportEqualsDeclaration:exit"?: ImportEqualsDeclaration;
+  "ImportKeyword:exit"?: ImportExpression;
+  "ImportSpecifier:exit"?: ImportSpecifier;
+  "ImportType:exit"?: ImportTypeNode;
+  "IndexedAccessType:exit"?: IndexedAccessTypeNode;
+  "IndexSignature:exit"?: IndexSignatureDeclaration;
+  "InferType:exit"?: InferTypeNode;
+  "InterfaceDeclaration:exit"?: InterfaceDeclaration;
+  "IntersectionType:exit"?: IntersectionTypeNode;
+  "IntrinsicKeyword:exit"?: IntrinsicKeyword;
+  "JSDocAllType:exit"?: JSDocAllType;
+  "JSDocFunctionType:exit"?: JSDocFunctionType;
+  "JSDocLink:exit"?: JSDocLink;
+  "JSDocLinkCode:exit"?: JSDocLinkCode;
+  "JSDocLinkPlain:exit"?: JSDocLinkPlain;
+  "JSDocMemberName:exit"?: JSDocMemberName;
+  "JSDocNamepathType:exit"?: JSDocNamepathType;
+  "JSDocNonNullableType:exit"?: JSDocNonNullableType;
+  "JSDocNullableType:exit"?: JSDocNullableType;
+  "JSDocOptionalType:exit"?: JSDocOptionalType;
+  "JSDocParameterTag:exit"?: JSDocParameterTag;
+  "JSDocPropertyTag:exit"?: JSDocPropertyTag;
+  "JSDocReturnTag:exit"?: JSDocReturnTag;
+  "JSDocSignature:exit"?: JSDocSignature;
+  "JSDocTemplateTag:exit"?: JSDocTemplateTag;
+  "JSDocText:exit"?: JSDocText;
+  "JSDocTypeExpression:exit"?: JSDocTypeExpression;
+  "JSDocTypeLiteral:exit"?: JSDocTypeLiteral;
+  "JSDocUnknownType:exit"?: JSDocUnknownType;
+  "JSDocVariadicType:exit"?: JSDocVariadicType;
+  "JsxAttribute:exit"?: JsxAttribute;
+  "JsxAttributes:exit"?: JsxAttributes;
+  "JsxClosingElement:exit"?: JsxClosingElement;
+  "JsxClosingFragment:exit"?: JsxClosingFragment;
+  "JsxElement:exit"?: JsxElement;
+  "JsxExpression:exit"?: JsxExpression;
+  "JsxFragment:exit"?: JsxFragment;
+  "JsxNamespacedName:exit"?: JsxNamespacedName;
+  "JsxOpeningElement:exit"?: JsxOpeningElement;
+  "JsxOpeningFragment:exit"?: JsxOpeningFragment;
+  "JsxSelfClosingElement:exit"?: JsxSelfClosingElement;
+  "JsxSpreadAttribute:exit"?: JsxSpreadAttribute;
+  "JsxText:exit"?: JsxText;
+  "LabeledStatement:exit"?: LabeledStatement;
+  "LiteralType:exit"?: LiteralTypeNode;
+  "MappedType:exit"?: MappedTypeNode;
+  "MetaProperty:exit"?: MetaProperty;
+  "MethodDeclaration:exit"?: MethodDeclaration;
+  "MethodSignature:exit"?: MethodSignature;
+  "MissingDeclaration:exit"?: MissingDeclaration;
+  "ModuleBlock:exit"?: ModuleBlock;
+  "ModuleDeclaration:exit"?: ModuleDeclaration;
+  "NamedExports:exit"?: NamedExports;
+  "NamedImports:exit"?: NamedImports;
+  "NamedTupleMember:exit"?: NamedTupleMember;
+  "NamespaceExport:exit"?: NamespaceExport;
+  "NamespaceExportDeclaration:exit"?: NamespaceExportDeclaration;
+  "NamespaceImport:exit"?: NamespaceImport;
+  "NeverKeyword:exit"?: NeverKeyword;
+  "NewExpression:exit"?: NewExpression;
+  "NonNullExpression:exit"?: NonNullExpression;
+  "NoSubstitutionTemplateLiteral:exit"?: NoSubstitutionTemplateLiteral;
+  "NotEmittedStatement:exit"?: NotEmittedStatement;
+  "NotEmittedTypeElement:exit"?: NotEmittedTypeElement;
+  "NullKeyword:exit"?: NullLiteral;
+  "NumberKeyword:exit"?: NumberKeyword;
+  "NumericLiteral:exit"?: NumericLiteral;
+  "ObjectBindingPattern:exit"?: ObjectBindingPattern;
+  "ObjectKeyword:exit"?: ObjectKeyword;
+  "ObjectLiteralExpression:exit"?: ObjectLiteralExpression;
+  "OmittedExpression:exit"?: OmittedExpression;
+  "OptionalType:exit"?: OptionalTypeNode;
+  "Parameter:exit"?: ParameterDeclaration;
+  "ParenthesizedExpression:exit"?: ParenthesizedExpression;
+  "ParenthesizedType:exit"?: ParenthesizedTypeNode;
+  "PartiallyEmittedExpression:exit"?: PartiallyEmittedExpression;
+  "PostfixUnaryExpression:exit"?: PostfixUnaryExpression;
+  "PrefixUnaryExpression:exit"?: PrefixUnaryExpression;
+  "PrivateIdentifier:exit"?: PrivateIdentifier;
+  "PropertyAccessExpression:exit"?: PropertyAccessExpression;
+  "PropertyAssignment:exit"?: PropertyAssignment;
+  "PropertyDeclaration:exit"?: PropertyDeclaration;
+  "PropertySignature:exit"?: PropertySignature;
+  "QualifiedName:exit"?: QualifiedName;
+  "RegularExpressionLiteral:exit"?: RegularExpressionLiteral;
+  "RestType:exit"?: RestTypeNode;
+  "ReturnStatement:exit"?: ReturnStatement;
+  "SatisfiesExpression:exit"?: SatisfiesExpression;
+  "SemicolonClassElement:exit"?: SemicolonClassElement;
+  "SetAccessor:exit"?: SetAccessorDeclaration;
+  "ShorthandPropertyAssignment:exit"?: ShorthandPropertyAssignment;
+  "SourceFile:exit"?: SourceFile;
+  "SpreadAssignment:exit"?: SpreadAssignment;
+  "SpreadElement:exit"?: SpreadElement;
+  "StringKeyword:exit"?: StringKeyword;
+  "StringLiteral:exit"?: StringLiteral;
+  "SuperKeyword:exit"?: SuperExpression;
+  "SwitchStatement:exit"?: SwitchStatement;
+  "SymbolKeyword:exit"?: SymbolKeyword;
+  "SyntheticExpression:exit"?: SyntheticExpression;
+  "TaggedTemplateExpression:exit"?: TaggedTemplateExpression;
+  "TemplateExpression:exit"?: TemplateExpression;
+  "TemplateHead:exit"?: TemplateHead;
+  "TemplateLiteralType:exit"?: TemplateLiteralTypeNode;
+  "TemplateLiteralTypeSpan:exit"?: TemplateLiteralTypeSpan;
+  "TemplateMiddle:exit"?: TemplateMiddle;
+  "TemplateSpan:exit"?: TemplateSpan;
+  "TemplateTail:exit"?: TemplateTail;
+  "ThisKeyword:exit"?: ThisExpression;
+  "ThisType:exit"?: ThisTypeNode;
+  "ThrowStatement:exit"?: ThrowStatement;
+  "TrueKeyword:exit"?: TrueLiteral;
+  "TryStatement:exit"?: TryStatement;
+  "TupleType:exit"?: TupleTypeNode;
+  "TypeAliasDeclaration:exit"?: TypeAliasDeclaration;
+  "TypeAssertionExpression:exit"?: TypeAssertion;
+  "TypeLiteral:exit"?: TypeLiteralNode;
+  "TypeOfExpression:exit"?: TypeOfExpression;
+  "TypeOperator:exit"?: TypeOperatorNode;
+  "TypeParameter:exit"?: TypeParameterDeclaration;
+  "TypePredicate:exit"?: TypePredicateNode;
+  "TypeQuery:exit"?: TypeQueryNode;
+  "TypeReference:exit"?: TypeReferenceNode;
+  "UndefinedKeyword:exit"?: UndefinedKeyword;
+  "UnionType:exit"?: UnionTypeNode;
+  "UnknownKeyword:exit"?: UnknownKeyword;
+  "VariableDeclaration:exit"?: VariableDeclaration;
+  "VariableDeclarationList:exit"?: VariableDeclarationList;
+  "VariableStatement:exit"?: VariableStatement;
+  "VoidExpression:exit"?: VoidExpression;
+  "VoidKeyword:exit"?: VoidKeyword;
+  "WhileStatement:exit"?: WhileStatement;
+  "WithStatement:exit"?: WithStatement;
+  "YieldExpression:exit"?: YieldExpression;
+}>, TypeScriptFileServices>;
+declare function throwUnknownLanguageExtension(filename: string): never;
 //#endregion
-export { TypeScriptFileServices, typescriptLanguage };
+export { NodeSyntaxKinds, TypeScriptFileServices, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage };
 //# sourceMappingURL=language.d.ts.map