tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/program-checker.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Binding and checking a program: the checker host over a `Program`, and the bind, semantic,
+ * suggestion and global diagnostics of its files, like tsgo's `Program`.
+ *
+ * ```ts
+ * const checked = new CheckedProgram(program);
+ * const errors = checked.getSemanticDiagnostics(undefined);
+ * ```
+ */
+import { type Node, type SourceFile } from './ast.js';
+import { Checker, CheckerHost } from './checker.js';
+import { Diagnostic } from './diagnostics.js';
+import type { EmitResult } from './emitter.js';
+import type { CompilerOptions, ModuleKind } from './options.js';
+import type { ResolvedModule } from './module-resolution-types.js';
+import { ModuleSpecifierHost } from './module-specifiers.js';
+import type { OutputPathsHost } from './output-paths.js';
+import type { PackageJsonInfo } from './package-json.js';
+import type { KnownSymlinks } from './symlinks.js';
+import type { MergedGlobals } from './checker-symbols.js';
+import { Program } from './program.js';
+import { type SourceFileMetadata } from './program-utilities.js';
+/** What the checker needs, answered by a program. */
+export declare class ProgramCheckerHost extends CheckerHost {
+    readonly program: Program;
+    private specifierHost;
+    constructor(program: Program);
+    getCompilerOptions(): CompilerOptions;
+    getSourceFiles(): readonly SourceFile[];
+    isSourceFileDefaultLibrary(file: SourceFile): boolean;
+    getResolvedModule(file: SourceFile, moduleName: string, mode: ModuleKind): ResolvedModule | undefined;
+    getSourceFileForResolvedModule(fileName: string): SourceFile | undefined;
+    getModeForUsageLocation(file: SourceFile, location: Node): ModuleKind;
+    getDefaultResolutionModeForFile(file: SourceFile): ModuleKind;
+    getPackagesMap(): ReadonlyMap<string, boolean>;
+    getProjectReferenceOutputDts(fileName: string): string;
+    fileExists(path: string): boolean;
+    getImportHelpersImportSpecifier(file: SourceFile): Node | undefined;
+    getJSXRuntimeImportSpecifier(file: SourceFile): Node | undefined;
+    getMergedGlobals(): MergedGlobals | undefined;
+    getImpliedNodeFormatForEmit(file: SourceFile): ModuleKind;
+    getEmitSyntaxForUsageLocation(file: SourceFile, usage: Node): ModuleKind;
+    getSourceFileMetadata(file: SourceFile): SourceFileMetadata | undefined;
+    getEmitModuleFormatOfFile(file: SourceFile): ModuleKind;
+    getModuleSpecifierHost(): ModuleSpecifierHost | undefined;
+}
+/** Module specifier generation over a program. */
+export declare class ProgramModuleSpecifierHost extends ModuleSpecifierHost {
+    readonly program: Program;
+    constructor(program: Program);
+    getCurrentDirectory(): string;
+    useCaseSensitiveFileNames(): boolean;
+    getSymlinkCache(): KnownSymlinks | undefined;
+    getGlobalTypingsCacheLocation(): string;
+    getProjectReferenceOutputDts(path: string): string;
+    getRedirectTargets(path: string): readonly string[];
+    getSourceOfProjectReferenceIfOutputIncluded(file: SourceFile): string;
+    fileExists(path: string): boolean;
+    getNearestAncestorDirectoryWithPackageJson(directory: string): string;
+    getPackageJsonInfo(packageJsonPath: string): PackageJsonInfo | undefined;
+    getDefaultResolutionModeForFile(file: SourceFile): ModuleKind;
+    getResolvedModuleFromModuleSpecifier(file: SourceFile, specifier: Node): ResolvedModule | undefined;
+    getModeForUsageLocation(file: SourceFile, specifier: Node): ModuleKind;
+    getOutputPathsHost(): OutputPathsHost;
+}
+/** Binds every file of `program`. */
+export declare function bindProgram(program: Program): void;
+/**
+ * A bound program with the checker that reports its diagnostics. It checks every file, the default
+ * library files too, as tsgo's checker does with the files it is given.
+ */
+export declare class CheckedProgram {
+    readonly program: Program;
+    private reportingChecker;
+    constructor(program: Program);
+    /**
+     * The checker that reports diagnostics, created on first use: with `--checkers`, after the checker
+     * threads are started (parallel-check.ts), so creating it (merging the globals) is not on the way to
+     * checking.
+     */
+    get checker(): Checker;
+    /** A new checker for the program, independent of the one reporting diagnostics. */
+    createChecker(): Checker;
+    /** Frees the checker that reports the program's diagnostics (`disposeChecker`). */
+    disposeCheckers(): void;
+    getBindDiagnostics(file: SourceFile | undefined): Diagnostic[];
+    /**
+     * Diagnostics of checker threads (parallel-check.ts): the semantic diagnostics of each file by file
+     * index, before `noEmit` filtering (`unfilteredDiagnosticsOfFile`), and their global diagnostics. Set
+     * once every file is checked.
+     */
+    checkedInParallel: (Diagnostic[] | undefined)[] | undefined;
+    /**
+     * The files checker threads check, where only some are (the affected files of an incremental
+     * program's rebuild); `undefined` for every file. The others are checked on this thread when asked.
+     */
+    checkOnly: ReadonlySet<SourceFile> | undefined;
+    /** Whether the program is shared with checker threads (`shareWithCheckers`, parallel-check.ts). */
+    sharedWithCheckers: boolean;
+    /**
+     * The number of threads, this one included, that compare the references of the files of an incremental
+     * program with its old state where the program is shared with checker threads (`compareReferencesOnThreads`,
+     * incremental.ts); 1 compares on this thread.
+     */
+    referenceThreads: number;
+    readonly parallelGlobalDiagnostics: Diagnostic[];
+    /**
+     * The declaration diagnostics checker threads computed under `noEmit` (PlainProgram,
+     * IncrementalProgram), by file index; `undefined` for files they did not. Set once every file is
+     * checked.
+     */
+    declarationsInParallel: (Diagnostic[] | undefined)[] | undefined;
+    /**
+     * What checker threads emitted (PlainProgram), by file index; `undefined` for files they did not
+     * emit. Set once every file is checked, when checker threads emit (parallel-check.ts).
+     */
+    emittedInParallel: (EmitResult | undefined)[] | undefined;
+    /**
+     * The global diagnostics of this thread's checker before it emitted files while checker threads
+     * checked (`emitUncheckedFiles`), reported instead of its current ones.
+     */
+    ownGlobalDiagnostics: Diagnostic[] | undefined;
+    getSemanticDiagnostics(file: SourceFile | undefined): Diagnostic[];
+    /** The semantic diagnostics of `file`, unsorted. */
+    semanticDiagnosticsOfFile(file: SourceFile): Diagnostic[];
+    /**
+     * The semantic diagnostics of `file`, unsorted, before `noEmit` filtering: the bind and check
+     * diagnostics, then the include errors. Checker threads report these (parallel-check.ts), so that an
+     * incremental program keeps them unfiltered under `noEmit` too.
+     */
+    unfilteredDiagnosticsOfFile(file: SourceFile): Diagnostic[];
+    /**
+     * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
+     * Once checker threads checked the program, they come from the threads' diagnostics of the file,
+     * without the include errors added last.
+     */
+    getSemanticDiagnosticsWithoutNoEmitFiltering(file: SourceFile): Diagnostic[];
+    /** The declaration diagnostics checker threads computed for `file` (`declarationsInParallel`), if any. */
+    declarationDiagnosticsInParallel(file: SourceFile): Diagnostic[] | undefined;
+    private fileIndexes;
+    /** The index of `file` in the program's files. */
+    private indexOfFile;
+    getSuggestionDiagnostics(file: SourceFile | undefined): Diagnostic[];
+    /**
+     * Diagnostics without a file, once every file is checked. Without `withCheckerThreads`, those of the
+     * reporting checkers only, as before checking: checker threads (parallel-check.ts) also report
+     * those they found checking files.
+     */
+    getGlobalDiagnostics(withCheckerThreads?: boolean): Diagnostic[];
+    /** Whether `file`'s bind and check diagnostics are reported. */
+    skipTypeChecking(file: SourceFile): boolean;
+    private collect;
+    private collectChecked;
+    private getBindAndCheckDiagnostics;
+    getIncludeProcessorDiagnostics(file: SourceFile): Diagnostic[];
+}

package/dist/api/compiler/program-checker.js

@@ -0,0 +1,526 @@
+import { Checker, CheckerHost, disposeChecker } from './checker.js';
+import { createDiagnostic, messageCode } from './diagnostics.js';
+import { ModuleSpecifierHost } from './module-specifiers.js';
+import { sortAndDeduplicateDiagnostics } from './program.js';
+import { getEmitModuleFormatOfFile, getEmitSyntaxForUsageLocation, isCheckJsEnabledForFile, } from './program-utilities.js';
+import { bindSourceFile } from './binder.js';
+import { computeLineOfPosition } from './scanner.js';
+/** What the checker needs, answered by a program. */
+export class ProgramCheckerHost extends CheckerHost {
+    program;
+    specifierHost = undefined;
+    constructor(program) {
+        super();
+        this.program = program;
+    }
+    getCompilerOptions() {
+        return this.program.options;
+    }
+    getSourceFiles() {
+        return this.program.getSourceFiles();
+    }
+    isSourceFileDefaultLibrary(file) {
+        return this.program.isSourceFileDefaultLibrary(file.path);
+    }
+    getResolvedModule(file, moduleName, mode) {
+        return this.program.getResolvedModule(file, moduleName, mode);
+    }
+    getSourceFileForResolvedModule(fileName) {
+        return this.program.getSourceFileForResolvedModule(fileName);
+    }
+    getModeForUsageLocation(file, location) {
+        return this.program.getModeForUsageLocation(file, location);
+    }
+    getDefaultResolutionModeForFile(file) {
+        return this.program.getDefaultResolutionModeForFile(file);
+    }
+    getPackagesMap() {
+        return this.program.getPackagesMap();
+    }
+    getProjectReferenceOutputDts(fileName) {
+        const program = this.program;
+        return program.getProjectReferenceFromSource(program.toPath(fileName))?.outputDts ?? '';
+    }
+    fileExists(path) {
+        return this.program.host.fs.fileExists(path);
+    }
+    getImportHelpersImportSpecifier(file) {
+        return this.program.importHelpersImportSpecifier(file.path);
+    }
+    getJSXRuntimeImportSpecifier(file) {
+        return this.program.jsxRuntimeImportSpecifier(file.path);
+    }
+    getMergedGlobals() {
+        return this.program.mergedGlobals;
+    }
+    getImpliedNodeFormatForEmit(file) {
+        return this.program.getImpliedNodeFormatForEmit(file);
+    }
+    getEmitSyntaxForUsageLocation(file, usage) {
+        const program = this.program;
+        return getEmitSyntaxForUsageLocation(file.fileName, program.sourceFileMetadata(file.path), usage, program.getCompilerOptionsForFile(file));
+    }
+    getSourceFileMetadata(file) {
+        return this.program.sourceFileMetadata(file.path);
+    }
+    getEmitModuleFormatOfFile(file) {
+        const program = this.program;
+        return getEmitModuleFormatOfFile(file.fileName, program.getCompilerOptionsForFile(file), program.sourceFileMetadata(file.path));
+    }
+    getModuleSpecifierHost() {
+        let host = this.specifierHost;
+        if (host === undefined) {
+            host = new ProgramModuleSpecifierHost(this.program);
+            this.specifierHost = host;
+        }
+        return host;
+    }
+}
+/** Module specifier generation over a program. */
+export class ProgramModuleSpecifierHost extends ModuleSpecifierHost {
+    program;
+    constructor(program) {
+        super();
+        this.program = program;
+    }
+    getCurrentDirectory() {
+        return this.program.currentDirectory;
+    }
+    useCaseSensitiveFileNames() {
+        return this.program.useCaseSensitiveFileNames;
+    }
+    getSymlinkCache() {
+        return this.program.getSymlinkCache();
+    }
+    getGlobalTypingsCacheLocation() {
+        return this.program.getGlobalTypingsCacheLocation();
+    }
+    getProjectReferenceOutputDts(path) {
+        return this.program.getProjectReferenceFromSource(path)?.outputDts ?? '';
+    }
+    getRedirectTargets(path) {
+        return this.program.getRedirectTargets(path);
+    }
+    getSourceOfProjectReferenceIfOutputIncluded(file) {
+        return this.program.getSourceOfProjectReferenceIfOutputIncluded(file.path, file.fileName);
+    }
+    fileExists(path) {
+        return this.program.host.fs.fileExists(path);
+    }
+    getNearestAncestorDirectoryWithPackageJson(directory) {
+        return this.program.getNearestAncestorDirectoryWithPackageJson(directory);
+    }
+    getPackageJsonInfo(packageJsonPath) {
+        return this.program.getPackageJsonInfo(packageJsonPath);
+    }
+    getDefaultResolutionModeForFile(file) {
+        return this.program.getDefaultResolutionModeForFile(file);
+    }
+    getResolvedModuleFromModuleSpecifier(file, specifier) {
+        return this.program.getResolvedModuleFromModuleSpecifier(file, specifier);
+    }
+    getModeForUsageLocation(file, specifier) {
+        return this.program.getModeForUsageLocation(file, specifier);
+    }
+    getOutputPathsHost() {
+        return this.program;
+    }
+}
+/** Binds every file of `program`. */
+export function bindProgram(program) {
+    for (const file of program.getSourceFiles())
+        bindSourceFile(file);
+}
+/**
+ * A bound program with the checker that reports its diagnostics. It checks every file, the default
+ * library files too, as tsgo's checker does with the files it is given.
+ */
+export class CheckedProgram {
+    program;
+    reportingChecker = undefined;
+    constructor(program) {
+        this.program = program;
+        bindProgram(program);
+    }
+    /**
+     * The checker that reports diagnostics, created on first use: with `--checkers`, after the checker
+     * threads are started (parallel-check.ts), so creating it (merging the globals) is not on the way to
+     * checking.
+     */
+    get checker() {
+        let checker = this.reportingChecker;
+        if (checker === undefined) {
+            checker = new Checker(new ProgramCheckerHost(this.program));
+            this.reportingChecker = checker;
+        }
+        return checker;
+    }
+    /** A new checker for the program, independent of the one reporting diagnostics. */
+    createChecker() {
+        return new Checker(new ProgramCheckerHost(this.program));
+    }
+    /** Frees the checker that reports the program's diagnostics (`disposeChecker`). */
+    disposeCheckers() {
+        if (this.reportingChecker !== undefined)
+            disposeChecker(this.reportingChecker);
+        this.reportingChecker = undefined;
+    }
+    getBindDiagnostics(file) {
+        return this.collect(file, (f) => f.bindDiagnostics);
+    }
+    /**
+     * Diagnostics of checker threads (parallel-check.ts): the semantic diagnostics of each file by file
+     * index, before `noEmit` filtering (`unfilteredDiagnosticsOfFile`), and their global diagnostics. Set
+     * once every file is checked.
+     */
+    checkedInParallel = undefined;
+    /**
+     * The files checker threads check, where only some are (the affected files of an incremental
+     * program's rebuild); `undefined` for every file. The others are checked on this thread when asked.
+     */
+    checkOnly = undefined;
+    /** Whether the program is shared with checker threads (`shareWithCheckers`, parallel-check.ts). */
+    sharedWithCheckers = false;
+    /**
+     * The number of threads, this one included, that compare the references of the files of an incremental
+     * program with its old state where the program is shared with checker threads (`compareReferencesOnThreads`,
+     * incremental.ts); 1 compares on this thread.
+     */
+    referenceThreads = 1;
+    parallelGlobalDiagnostics = [];
+    /**
+     * The declaration diagnostics checker threads computed under `noEmit` (PlainProgram,
+     * IncrementalProgram), by file index; `undefined` for files they did not. Set once every file is
+     * checked.
+     */
+    declarationsInParallel = undefined;
+    /**
+     * What checker threads emitted (PlainProgram), by file index; `undefined` for files they did not
+     * emit. Set once every file is checked, when checker threads emit (parallel-check.ts).
+     */
+    emittedInParallel = undefined;
+    /**
+     * The global diagnostics of this thread's checker before it emitted files while checker threads
+     * checked (`emitUncheckedFiles`), reported instead of its current ones.
+     */
+    ownGlobalDiagnostics = undefined;
+    getSemanticDiagnostics(file) {
+        const parallel = this.checkedInParallel;
+        if (file === undefined && parallel !== undefined) {
+            const noEmit = this.program.options.noEmit === true;
+            const result = [];
+            for (const diagnostics of parallel)
+                if (diagnostics !== undefined)
+                    for (const d of diagnostics)
+                        if (!noEmit || !d.skippedOnNoEmit)
+                            result.push(d);
+            return sortAndDeduplicateDiagnostics(result);
+        }
+        return this.collectChecked(file, (f) => this.semanticDiagnosticsOfFile(f));
+    }
+    /** The semantic diagnostics of `file`, unsorted. */
+    semanticDiagnosticsOfFile(file) {
+        const diagnostics = this.unfilteredDiagnosticsOfFile(file);
+        if (this.program.options.noEmit !== true)
+            return diagnostics;
+        const result = [];
+        for (const d of diagnostics)
+            if (!d.skippedOnNoEmit)
+                result.push(d);
+        return result;
+    }
+    /**
+     * The semantic diagnostics of `file`, unsorted, before `noEmit` filtering: the bind and check
+     * diagnostics, then the include errors. Checker threads report these (parallel-check.ts), so that an
+     * incremental program keeps them unfiltered under `noEmit` too.
+     */
+    unfilteredDiagnosticsOfFile(file) {
+        const result = this.getBindAndCheckDiagnostics(file);
+        for (const d of this.getIncludeProcessorDiagnostics(file))
+            result.push(d);
+        return result;
+    }
+    /**
+     * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
+     * Once checker threads checked the program, they come from the threads' diagnostics of the file,
+     * without the include errors added last.
+     */
+    getSemanticDiagnosticsWithoutNoEmitFiltering(file) {
+        if (this.skipTypeChecking(file))
+            return [];
+        const parallel = this.checkedInParallel;
+        const diagnostics = parallel === undefined ? undefined : parallel[this.indexOfFile(file)];
+        if (diagnostics !== undefined) {
+            const count = diagnostics.length - this.getIncludeProcessorDiagnostics(file).length;
+            return sortAndDeduplicateDiagnostics(diagnostics.slice(0, count));
+        }
+        return sortAndDeduplicateDiagnostics(this.getBindAndCheckDiagnostics(file));
+    }
+    /** The declaration diagnostics checker threads computed for `file` (`declarationsInParallel`), if any. */
+    declarationDiagnosticsInParallel(file) {
+        const parallel = this.declarationsInParallel;
+        return parallel === undefined ? undefined : parallel[this.indexOfFile(file)];
+    }
+    fileIndexes = undefined;
+    /** The index of `file` in the program's files. */
+    indexOfFile(file) {
+        let indexes = this.fileIndexes;
+        if (indexes === undefined) {
+            indexes = new Map();
+            const files = this.program.getSourceFiles();
+            for (let i = 0; i < files.length; i++)
+                indexes.set(files[i], i);
+            this.fileIndexes = indexes;
+        }
+        return indexes.get(file);
+    }
+    getSuggestionDiagnostics(file) {
+        return this.collectChecked(file, (f) => this.checker.getSuggestionDiagnostics(f));
+    }
+    /**
+     * Diagnostics without a file, once every file is checked. Without `withCheckerThreads`, those of the
+     * reporting checkers only, as before checking: checker threads (parallel-check.ts) also report
+     * those they found checking files.
+     */
+    getGlobalDiagnostics(withCheckerThreads = true) {
+        if (this.program.getSourceFiles().length === 0)
+            return [];
+        const parallel = withCheckerThreads ? this.parallelGlobalDiagnostics : [];
+        const own = this.ownGlobalDiagnostics ?? this.checker.getGlobalDiagnostics();
+        if (parallel.length === 0)
+            return own;
+        return sortAndDeduplicateDiagnostics([...own, ...parallel]);
+    }
+    /** Whether `file`'s bind and check diagnostics are reported. */
+    skipTypeChecking(file) {
+        const options = this.program.options;
+        return (options.noCheck === true ||
+            (options.skipLibCheck === true && file.isDeclarationFile) ||
+            (options.skipDefaultLibCheck === true && this.program.isSourceFileDefaultLibrary(file.path)) ||
+            this.program.getProjectReferenceFromSource(file.path) !== undefined ||
+            !canIncludeBindAndCheckDiagnostics(file, options));
+    }
+    collect(file, get) {
+        if (file !== undefined)
+            return sortAndDeduplicateDiagnostics(get(file));
+        const result = [];
+        for (const f of this.program.getSourceFiles())
+            for (const d of get(f))
+                result.push(d);
+        return sortAndDeduplicateDiagnostics(result);
+    }
+    collectChecked(file, get) {
+        if (file !== undefined)
+            return this.skipTypeChecking(file) ? [] : sortAndDeduplicateDiagnostics(get(file));
+        const result = [];
+        for (const f of this.program.getSourceFiles()) {
+            if (this.skipTypeChecking(f))
+                continue;
+            for (const d of get(f))
+                result.push(d);
+        }
+        return sortAndDeduplicateDiagnostics(result);
+    }
+    getBindAndCheckDiagnostics(file) {
+        const options = this.program.options;
+        const diagnostics = file.bindDiagnostics.slice();
+        for (const d of this.checker.getDiagnostics(file))
+            diagnostics.push(d);
+        if (isPlainJSFile(file, options)) {
+            const result = [];
+            for (const d of diagnostics)
+                if (plainJSErrors.has(d.code))
+                    result.push(d);
+            return result;
+        }
+        if (isJSFile(file) && isCheckJsEnabledForFile(file, options)) {
+            for (const d of file.jsDocDiagnostics)
+                diagnostics.push(d);
+        }
+        const directives = new Directives(file);
+        const filtered = directives.filter(diagnostics);
+        for (const directive of directives.unused()) {
+            filtered.push(createDiagnostic(file.diagnosticFile(), directive.pos, directive.end, 729 /* Diagnostics.Unused_ts_expect_error_directive */));
+        }
+        return filtered;
+    }
+    getIncludeProcessorDiagnostics(file) {
+        if (this.skipTypeChecking(file))
+            return [];
+        const diagnostics = this.program.getIncludeProcessorDiagnostics(file);
+        return diagnostics.length === 0 ? diagnostics : new Directives(file).filter(diagnostics);
+    }
+}
+/** The `@ts-ignore` and `@ts-expect-error` comments of a file, by line. */
+class Directives {
+    file;
+    byLine = new Map();
+    constructor(file) {
+        this.file = file;
+        const lineStarts = file.diagnosticFile().getLineStarts();
+        for (const directive of file.commentDirectives) {
+            const line = computeLineOfPosition(lineStarts, directive.pos);
+            this.byLine.set(line, { pos: directive.pos, end: directive.end, kind: directive.kind });
+        }
+    }
+    /** The diagnostics no directive suppresses; a suppressing `@ts-expect-error` counts as used. */
+    filter(diagnostics) {
+        if (this.byLine.size === 0)
+            return diagnostics.slice();
+        const text = this.file.text;
+        const lineStarts = this.file.diagnosticFile().getLineStarts();
+        const result = [];
+        for (const diagnostic of diagnostics) {
+            let ignored = false;
+            for (let line = computeLineOfPosition(lineStarts, diagnostic.pos) - 1; line >= 0; line--) {
+                const directive = this.byLine.get(line);
+                if (directive !== undefined) {
+                    ignored = true;
+                    directive.kind = 2 /* CommentDirectiveKind.Ignore */;
+                    break;
+                }
+                if (!isCommentOrBlankLine(text, lineStarts[line]))
+                    break;
+            }
+            if (!ignored)
+                result.push(diagnostic);
+        }
+        return result;
+    }
+    /** `@ts-expect-error` comments that suppressed nothing. */
+    unused() {
+        const result = [];
+        for (const directive of this.byLine.values()) {
+            if (directive.kind === 1 /* CommentDirectiveKind.ExpectError */)
+                result.push(directive);
+        }
+        return result;
+    }
+}
+function isCommentOrBlankLine(text, lineStart) {
+    let pos = lineStart;
+    while (pos < text.length && (text.charCodeAt(pos) === 0x20 || text.charCodeAt(pos) === 0x09))
+        pos += 1;
+    if (pos === text.length)
+        return true;
+    const ch = text.charCodeAt(pos);
+    if (ch === 0x0d || ch === 0x0a)
+        return true;
+    return pos + 1 < text.length && ch === 0x2f && text.charCodeAt(pos + 1) === 0x2f;
+}
+function isJSFile(file) {
+    return file.scriptKind === 1 /* ScriptKind.JS */ || file.scriptKind === 2 /* ScriptKind.JSX */;
+}
+/** A JavaScript file without `@ts-check` or `@ts-nocheck` when `checkJs` is unset. */
+function isPlainJSFile(file, options) {
+    return isJSFile(file) && file.checkJsDirective === undefined && options.checkJs === undefined;
+}
+function canIncludeBindAndCheckDiagnostics(file, options) {
+    if (file.checkJsDirective !== undefined && !file.checkJsDirective.enabled)
+        return false;
+    const kind = file.scriptKind;
+    if (kind === 3 /* ScriptKind.TS */ || kind === 4 /* ScriptKind.TSX */ || kind === 5 /* ScriptKind.External */)
+        return true;
+    const isCheckJS = isJSFile(file) && isCheckJsEnabledForFile(file, options);
+    return isPlainJSFile(file, options) || isCheckJS || kind === 7 /* ScriptKind.Deferred */;
+}
+/** The errors reported in JavaScript files that aren't type checked. */
+const plainJSErrors = codesOf([
+    619 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */,
+    686 /* Diagnostics.A_module_cannot_have_multiple_default_exports */,
+    885 /* Diagnostics.Another_export_default_is_here */,
+    884 /* Diagnostics.The_first_export_default_is_here */,
+    211 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module */,
+    167 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode */,
+    293 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here */,
+    1834 /* Diagnostics.X_constructor_is_a_reserved_word */,
+    71 /* Diagnostics.X_delete_cannot_be_called_on_an_identifier_in_strict_mode */,
+    163 /* Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode */,
+    168 /* Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode */,
+    69 /* Diagnostics.Invalid_use_of_0_in_strict_mode */,
+    278 /* Diagnostics.A_label_is_not_allowed_here */,
+    70 /* Diagnostics.X_with_statements_are_not_allowed_in_strict_mode */,
+    74 /* Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement */,
+    84 /* Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement */,
+    164 /* Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name */,
+    198 /* Diagnostics.A_class_member_cannot_have_the_0_keyword */,
+    127 /* Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name */,
+    73 /* Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement */,
+    83 /* Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement */,
+    81 /* Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement */,
+    207 /* Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration */,
+    205 /* Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context */,
+    138 /* Diagnostics.A_destructuring_declaration_must_have_an_initializer */,
+    40 /* Diagnostics.A_get_accessor_cannot_have_parameters */,
+    661 /* Diagnostics.A_rest_element_cannot_contain_a_binding_pattern */,
+    720 /* Diagnostics.A_rest_element_cannot_have_a_property_name */,
+    142 /* Diagnostics.A_rest_element_cannot_have_an_initializer */,
+    628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */,
+    35 /* Diagnostics.A_rest_parameter_cannot_have_an_initializer */,
+    10 /* Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list */,
+    9 /* Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma */,
+    1857 /* Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block */,
+    39 /* Diagnostics.A_set_accessor_cannot_have_rest_parameter */,
+    36 /* Diagnostics.A_set_accessor_must_have_exactly_one_parameter */,
+    389 /* Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module */,
+    149 /* Diagnostics.An_export_declaration_cannot_have_modifiers */,
+    388 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */,
+    147 /* Diagnostics.An_import_declaration_cannot_have_modifiers */,
+    119 /* Diagnostics.An_object_member_cannot_be_declared_optional */,
+    261 /* Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element */,
+    935 /* Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable */,
+    652 /* Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause */,
+    153 /* Diagnostics.Catch_clause_variable_cannot_have_an_initializer */,
+    1853 /* Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator */,
+    130 /* Diagnostics.Classes_can_only_extend_a_single_class */,
+    1829 /* Diagnostics.Classes_may_not_have_a_field_named_constructor */,
+    248 /* Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern */,
+    82 /* Diagnostics.Duplicate_label_0 */,
+    372 /* Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments */,
+    1855 /* Diagnostics.X_for_await_loops_cannot_be_used_inside_a_class_static_block */,
+    1804 /* Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression */,
+    1805 /* Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name */,
+    1830 /* Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array */,
+    776 /* Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names */,
+    76 /* Diagnostics.Jump_target_cannot_cross_function_boundary */,
+    156 /* Diagnostics.Line_terminator_not_permitted_before_arrow */,
+    140 /* Diagnostics.Modifiers_cannot_appear_here */,
+    60 /* Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement */,
+    144 /* Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement */,
+    1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */,
+    373 /* Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression */,
+    1835 /* Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier */,
+    292 /* Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain */,
+    75 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async */,
+    145 /* Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer */,
+    146 /* Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer */,
+    5 /* Diagnostics.Trailing_comma_not_allowed */,
+    90 /* Diagnostics.Variable_declaration_list_cannot_be_empty */,
+    1151 /* Diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses */,
+    2 /* Diagnostics.X_0_expected */,
+    1815 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */,
+    66 /* Diagnostics.X_0_list_cannot_be_empty */,
+    23 /* Diagnostics.X_0_modifier_already_seen */,
+    58 /* Diagnostics.X_0_modifier_cannot_appear_on_a_constructor_declaration */,
+    32 /* Diagnostics.X_0_modifier_cannot_appear_on_a_module_or_namespace_element */,
+    59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */,
+    24 /* Diagnostics.X_0_modifier_cannot_appear_on_class_elements_of_this_kind */,
+    31 /* Diagnostics.X_0_modifier_cannot_be_used_here */,
+    22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */,
+    116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */,
+    115 /* Diagnostics.X_0_declarations_must_be_initialized */,
+    128 /* Diagnostics.X_extends_clause_already_seen */,
+    643 /* Diagnostics.X_let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations */,
+    302 /* Diagnostics.Class_constructor_may_not_be_a_generator */,
+    276 /* Diagnostics.Class_constructor_may_not_be_an_accessor */,
+    246 /* Diagnostics.X_await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */,
+    972 /* Diagnostics.X_await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */,
+    80 /* Diagnostics.Private_field_0_must_be_declared_in_an_enclosing_class */,
+    961 /* Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value */,
+]);
+function codesOf(messages) {
+    const codes = new Set();
+    for (const message of messages)
+        codes.add(messageCode(message));
+    return codes;
+}