@atlaspack/reporter-lsp 2.14.5-canary.36 → 2.14.5-canary.361

package/dist/LspReporter.js

@@ -0,0 +1,414 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@atlaspack/utils");
+const plugin_1 = require("@atlaspack/plugin");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const url_1 = __importDefault(require("url"));
+const fs_1 = __importDefault(require("fs"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+// @ts-expect-error TS7016
+const ps = __importStar(require("ps-node"));
+const util_1 = require("util");
+const ipc_1 = require("./ipc");
+const lsp_protocol_1 = require("@atlaspack/lsp-protocol");
+const utils_2 = require("./utils");
+const lookupPid = (0, util_1.promisify)(ps.lookup);
+const ignoreFail = (func) => {
+    try {
+        func();
+    }
+    catch (e) {
+        /**/
+    }
+};
+const BASEDIR = fs_1.default.realpathSync(path_1.default.join(os_1.default.tmpdir(), 'parcel-lsp'));
+const SOCKET_FILE = path_1.default.join(BASEDIR, `parcel-${process.pid}`);
+const META_FILE = path_1.default.join(BASEDIR, `parcel-${process.pid}.json`);
+let workspaceDiagnostics = new utils_1.DefaultMap(() => []);
+const getWorkspaceDiagnostics = () => [...workspaceDiagnostics].map(([uri, diagnostics]) => ({
+    uri,
+    diagnostics,
+}));
+// @ts-expect-error TS7034
+let server;
+let connections = [];
+let bundleGraphDeferrable = (0, utils_1.makeDeferredWithPromise)();
+let bundleGraph = bundleGraphDeferrable.promise;
+let watchStarted = false;
+let lspStarted = false;
+// @ts-expect-error TS7034
+let watchStartPromise;
+const LSP_SENTINEL_FILENAME = 'lsp-server';
+const LSP_SENTINEL_FILE = path_1.default.join(BASEDIR, LSP_SENTINEL_FILENAME);
+async function watchLspActive() {
+    // Check for lsp-server when reporter is first started
+    try {
+        await fs_1.default.promises.access(LSP_SENTINEL_FILE, fs_1.default.constants.F_OK);
+        lspStarted = true;
+    }
+    catch {
+        //
+    }
+    // @ts-expect-error TS2769
+    return fs_1.default.watch(BASEDIR, (eventType, filename) => {
+        switch (eventType) {
+            case 'rename':
+                if (filename === LSP_SENTINEL_FILENAME) {
+                    fs_1.default.access(LSP_SENTINEL_FILE, fs_1.default.constants.F_OK, (err) => {
+                        if (err) {
+                            lspStarted = false;
+                        }
+                        else {
+                            lspStarted = true;
+                        }
+                    });
+                }
+        }
+    });
+}
+// @ts-expect-error TS2552
+async function doWatchStart(options) {
+    await fs_1.default.promises.mkdir(BASEDIR, { recursive: true });
+    // For each existing file, check if the pid matches a running process.
+    // If no process matches, delete the file, assuming it was orphaned
+    // by a process that quit unexpectedly.
+    for (let filename of fs_1.default.readdirSync(BASEDIR)) {
+        if (filename.endsWith('.json'))
+            continue;
+        let pid = parseInt(filename.slice('parcel-'.length), 10);
+        let resultList = await lookupPid({ pid });
+        if (resultList.length > 0)
+            continue;
+        fs_1.default.unlinkSync(path_1.default.join(BASEDIR, filename));
+        ignoreFail(() => fs_1.default.unlinkSync(path_1.default.join(BASEDIR, filename + '.json')));
+    }
+    server = await (0, ipc_1.createServer)(SOCKET_FILE, (connection) => {
+        // console.log('got connection');
+        connections.push(connection);
+        connection.onClose(() => {
+            connections = connections.filter((c) => c !== connection);
+        });
+        connection.onRequest(lsp_protocol_1.RequestDocumentDiagnostics, async (uri) => {
+            let graph = await bundleGraph;
+            if (!graph)
+                return;
+            // @ts-expect-error TS2345
+            return getDiagnosticsUnusedExports(graph, uri);
+        });
+        connection.onRequest(lsp_protocol_1.RequestImporters, async (params) => {
+            let graph = await bundleGraph;
+            if (!graph)
+                return null;
+            // @ts-expect-error TS2345
+            return getImporters(graph, params);
+        });
+        sendDiagnostics();
+    });
+    await fs_1.default.promises.writeFile(META_FILE, JSON.stringify({
+        projectRoot: options.projectRoot,
+        pid: process.pid,
+        argv: process.argv,
+    }));
+}
+watchLspActive();
+exports.default = new plugin_1.Reporter({
+    async report({ event, options }) {
+        if (event.type === 'watchStart') {
+            watchStarted = true;
+        }
+        if (watchStarted && lspStarted) {
+            // @ts-expect-error TS7005
+            if (!watchStartPromise) {
+                watchStartPromise = doWatchStart(options);
+            }
+            await watchStartPromise;
+        }
+        switch (event.type) {
+            case 'watchStart': {
+                break;
+            }
+            case 'buildStart': {
+                bundleGraphDeferrable = (0, utils_1.makeDeferredWithPromise)();
+                bundleGraph = bundleGraphDeferrable.promise;
+                updateBuildState('start');
+                clearDiagnostics();
+                break;
+            }
+            case 'buildSuccess':
+                bundleGraphDeferrable.deferred.resolve(event.bundleGraph);
+                updateBuildState('end');
+                sendDiagnostics();
+                break;
+            case 'buildFailure': {
+                bundleGraphDeferrable.deferred.resolve(undefined);
+                updateDiagnostics(event.diagnostics, 'error', options.projectRoot);
+                updateBuildState('end');
+                sendDiagnostics();
+                break;
+            }
+            case 'log':
+                if (
+                // @ts-expect-error TS2339
+                event.diagnostics != null &&
+                    (event.level === 'error' ||
+                        event.level === 'warn' ||
+                        event.level === 'info' ||
+                        event.level === 'verbose')) {
+                    updateDiagnostics(event.diagnostics, event.level, options.projectRoot);
+                }
+                break;
+            case 'buildProgress': {
+                let message = (0, utils_1.getProgressMessage)(event);
+                if (message != null) {
+                    updateBuildState('progress', message);
+                }
+                break;
+            }
+            case 'watchEnd':
+                connections.forEach((c) => c.end());
+                // @ts-expect-error TS7005
+                await server.close();
+                ignoreFail(() => fs_1.default.unlinkSync(META_FILE));
+                break;
+        }
+    },
+});
+function updateBuildState(state, message) {
+    connections.forEach((c) => c.sendNotification(lsp_protocol_1.NotificationBuildStatus, state, message));
+}
+function clearDiagnostics() {
+    workspaceDiagnostics.clear();
+}
+function sendDiagnostics() {
+    // console.log('send', getWorkspaceDiagnostics());
+    connections.forEach((c) => c.sendNotification(lsp_protocol_1.NotificationWorkspaceDiagnostics, getWorkspaceDiagnostics()));
+}
+function updateDiagnostics(parcelDiagnostics, parcelSeverity, projectRoot) {
+    for (let diagnostic of parcelDiagnostics) {
+        const codeFrames = diagnostic.codeFrames;
+        if (codeFrames == null) {
+            continue;
+        }
+        const firstCodeFrame = codeFrames[0];
+        const filePath = firstCodeFrame.filePath;
+        if (filePath == null) {
+            continue;
+        }
+        // We use the first highlight of the first codeFrame as the main Diagnostic,
+        // and we place everything else in the current Parcel diagnostic
+        // in relatedInformation
+        // https://code.visualstudio.com/api/references/vscode-api#DiagnosticRelatedInformation
+        const firstFrameHighlight = codeFrames[0].codeHighlights[0];
+        if (firstFrameHighlight == null) {
+            continue;
+        }
+        // @ts-expect-error TS2304
+        const relatedInformation = [];
+        for (const codeFrame of codeFrames) {
+            for (const highlight of codeFrame.codeHighlights) {
+                const filePath = codeFrame.filePath;
+                if (highlight === firstFrameHighlight || filePath == null) {
+                    continue;
+                }
+                relatedInformation.push({
+                    location: {
+                        uri: `file://${(0, utils_2.normalizeFilePath)(filePath, projectRoot)}`,
+                        range: {
+                            start: {
+                                line: highlight.start.line - 1,
+                                character: highlight.start.column - 1,
+                            },
+                            end: {
+                                line: highlight.end.line - 1,
+                                character: highlight.end.column,
+                            },
+                        },
+                    },
+                    message: highlight.message ?? diagnostic.message,
+                });
+            }
+        }
+        workspaceDiagnostics
+            .get(`file://${(0, utils_2.normalizeFilePath)(filePath, projectRoot)}`)
+            .push({
+            range: {
+                start: {
+                    line: firstFrameHighlight.start.line - 1,
+                    character: firstFrameHighlight.start.column - 1,
+                },
+                end: {
+                    line: firstFrameHighlight.end.line - 1,
+                    character: firstFrameHighlight.end.column,
+                },
+            },
+            source: diagnostic.origin,
+            severity: (0, utils_2.parcelSeverityToLspSeverity)(parcelSeverity),
+            message: diagnostic.message +
+                (firstFrameHighlight.message == null
+                    ? ''
+                    : ' ' + firstFrameHighlight.message),
+            relatedInformation,
+        });
+    }
+}
+function getDiagnosticsUnusedExports(bundleGraph, document) {
+    let filename = url_1.default.fileURLToPath(document);
+    let diagnostics = [];
+    let asset = bundleGraph.traverse((node, context, actions) => {
+        if (node.type === 'asset' && node.value.filePath === filename) {
+            actions.stop();
+            return node.value;
+        }
+    });
+    if (asset) {
+        // @ts-expect-error TS2304
+        const generateDiagnostic = (loc, type) => ({
+            range: {
+                start: {
+                    line: loc.start.line - 1,
+                    character: loc.start.column - 1,
+                },
+                end: {
+                    line: loc.end.line - 1,
+                    character: loc.end.column,
+                },
+            },
+            source: '@atlaspack/core',
+            severity: utils_2.DiagnosticSeverity.Hint,
+            message: `Unused ${type}.`,
+            tags: [utils_2.DiagnosticTag.Unnecessary],
+        });
+        // @ts-expect-error TS2345
+        let usedSymbols = bundleGraph.getUsedSymbols(asset);
+        if (usedSymbols) {
+            // @ts-expect-error TS2339
+            for (let [exported, symbol] of asset.symbols) {
+                if (!usedSymbols.has(exported)) {
+                    if (symbol.loc) {
+                        diagnostics.push(generateDiagnostic(symbol.loc, 'export'));
+                    }
+                }
+            }
+            // if (usedSymbols.size === 0 && asset.sideEffects !== false) {
+            //   diagnostics.push({
+            //     range: {
+            //       start: {
+            //         line: 0,
+            //         character: 0,
+            //       },
+            //       end: {
+            //         line: 0,
+            //         character: 1,
+            //       },
+            //     },
+            //     source: '@atlaspack/core',
+            //     severity: DiagnosticSeverity.Warning,
+            //     message: `Asset has no used exports, but is not marked as sideEffect-free so it cannot be excluded automatically.`,
+            //   });
+            // }
+        }
+        // @ts-expect-error TS2339
+        for (let dep of asset.getDependencies()) {
+            let usedSymbols = bundleGraph.getUsedSymbols(dep);
+            if (usedSymbols) {
+                for (let [exported, symbol] of dep.symbols) {
+                    if (!usedSymbols.has(exported) && symbol.isWeak && symbol.loc) {
+                        diagnostics.push(generateDiagnostic(symbol.loc, 'reexport'));
+                    }
+                }
+            }
+        }
+    }
+    return diagnostics;
+}
+// function getDefinition(
+//   bundleGraph: BundleGraph<PackagedBundle>,
+//   document: string,
+//   position: Position,
+// ): Array<LocationLink> | void {
+//   let filename = url.fileURLToPath(document);
+//   let asset = bundleGraph.traverse((node, context, actions) => {
+//     if (node.type === 'asset' && node.value.filePath === filename) {
+//       actions.stop();
+//       return node.value;
+//     }
+//   });
+//   if (asset) {
+//     for (let dep of bundleGraph.getDependencies(asset)) {
+//       let loc = dep.loc;
+//       if (loc && isInRange(loc, position)) {
+//         let resolution = bundleGraph.getResolvedAsset(dep);
+//         if (resolution) {
+//           return [
+//             {
+//               originSelectionRange: {
+//                 start: {
+//                   line: loc.start.line - 1,
+//                   character: loc.start.column - 1,
+//                 },
+//                 end: {line: loc.end.line - 1, character: loc.end.column},
+//               },
+//               targetUri: `file://${resolution.filePath}`,
+//               targetRange: RANGE_DUMMY,
+//               targetSelectionRange: RANGE_DUMMY,
+//             },
+//           ];
+//         }
+//       }
+//     }
+//   }
+// }
+function getImporters(bundleGraph, document) {
+    let filename = url_1.default.fileURLToPath(document);
+    let asset = bundleGraph.traverse((node, context, actions) => {
+        if (node.type === 'asset' && node.value.filePath === filename) {
+            actions.stop();
+            return node.value;
+        }
+    });
+    if (asset) {
+        // @ts-expect-error TS2345
+        let incoming = bundleGraph.getIncomingDependencies(asset);
+        return incoming
+            .filter((dep) => dep.sourcePath != null)
+            .map((dep) => `file://${(0, nullthrows_1.default)(dep.sourcePath)}`);
+    }
+    return null;
+}

package/dist/ipc.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const net = __importStar(require("net"));
+const node_1 = require("vscode-jsonrpc/node");
+function createClientPipeTransport(pipeName, onConnected) {
+    return new Promise((resolve, reject) => {
+        let server = net.createServer((socket) => {
+            onConnected(new node_1.SocketMessageReader(socket), new node_1.SocketMessageWriter(socket));
+        });
+        server.on('error', reject);
+        server.listen(pipeName, () => {
+            server.removeListener('error', reject);
+            resolve({
+                close() {
+                    return new Promise((res, rej) => {
+                        server.close((e) => {
+                            if (e)
+                                rej(e);
+                            // @ts-expect-error TS2794
+                            else
+                                res();
+                        });
+                    });
+                },
+            });
+        });
+    });
+}
+function createServer(filename, setup) {
+    return createClientPipeTransport(filename, (reader, writer) => {
+        let connection = (0, node_1.createMessageConnection)(reader, writer);
+        connection.listen();
+        setup(connection);
+    });
+}

package/dist/utils.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticSeverity = exports.DiagnosticTag = void 0;
+exports.parcelSeverityToLspSeverity = parcelSeverityToLspSeverity;
+exports.normalizeFilePath = normalizeFilePath;
+const path_1 = __importDefault(require("path"));
+function parcelSeverityToLspSeverity(parcelSeverity) {
+    switch (parcelSeverity) {
+        case 'error':
+            return exports.DiagnosticSeverity.Error;
+        case 'warn':
+            return exports.DiagnosticSeverity.Warning;
+        case 'info':
+            return exports.DiagnosticSeverity.Information;
+        case 'verbose':
+            return exports.DiagnosticSeverity.Hint;
+        default:
+            throw new Error('Unknown severity');
+    }
+}
+function normalizeFilePath(filePath, projectRoot) {
+    return path_1.default.isAbsolute(filePath)
+        ? filePath
+        : path_1.default.join(projectRoot, filePath);
+}
+// export function isInRange(loc: SourceLocation, position: Position): boolean {
+//   let pos = {line: position.line + 1, column: position.character + 1};
+//   if (pos.line < loc.start.line || loc.end.line < pos.line) {
+//     return false;
+//   }
+//   if (pos.line === loc.start.line) {
+//     return loc.start.column <= pos.column;
+//   }
+//   if (pos.line === loc.end.line - 1) {
+//     return pos.column < loc.start.column;
+//   }
+//   return true;
+// }
+// /** This range is used when refering to a whole file and not a specific range. */
+// export const RANGE_DUMMY: Range = {
+//   start: {line: 0, character: 0},
+//   end: {line: 0, character: 0},
+// };
+// Copied over from vscode-languageserver to prevent the runtime dependency
+exports.DiagnosticTag = {
+    /**
+     * Unused or unnecessary code.
+     *
+     * Clients are allowed to render diagnostics with this tag faded out instead of having
+     * an error squiggle.
+     */
+    // @ts-expect-error TS2304
+    Unnecessary: 1,
+    /**
+     * Deprecated or obsolete code.
+     *
+     * Clients are allowed to rendered diagnostics with this tag strike through.
+     */
+    // @ts-expect-error TS2304
+    Deprecated: 2,
+};
+exports.DiagnosticSeverity = {
+    /**
+     * Reports an error.
+     */
+    Error: 1,
+    /**
+     * Reports a warning.
+     */
+    Warning: 2,
+    /**
+     * Reports an information.
+     */
+    Information: 3,
+    /**
+     * Reports a hint.
+     */
+    Hint: 4,
+};

package/lib/LspReporter.js

@@ -79,6 +79,10 @@ var _utils2 = require("./utils");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS7016
+
+// @ts-expect-error TS7016
+
 const lookupPid = (0, _util().promisify)(ps().lookup);
 const ignoreFail = func => {
   try {
@@ -95,12 +99,15 @@ const getWorkspaceDiagnostics = () => [...workspaceDiagnostics].map(([uri, diagn
   uri,
   diagnostics
 }));
+
+// @ts-expect-error TS7034
 let server;
 let connections = [];
 let bundleGraphDeferrable = (0, _utils().makeDeferredWithPromise)();
 let bundleGraph = bundleGraphDeferrable.promise;
 let watchStarted = false;
 let lspStarted = false;
+// @ts-expect-error TS7034
 let watchStartPromise;
 const LSP_SENTINEL_FILENAME = 'lsp-server';
 const LSP_SENTINEL_FILE = _path().default.join(BASEDIR, LSP_SENTINEL_FILENAME);
@@ -112,6 +119,8 @@ async function watchLspActive() {
   } catch {
     //
   }
+
+  // @ts-expect-error TS2769
   return _fs().default.watch(BASEDIR, (eventType, filename) => {
     switch (eventType) {
       case 'rename':
@@ -127,6 +136,8 @@ async function watchLspActive() {
     }
   });
 }
+
+// @ts-expect-error TS2552
 async function doWatchStart(options) {
   await _fs().default.promises.mkdir(BASEDIR, {
     recursive: true
@@ -154,11 +165,15 @@ async function doWatchStart(options) {
     connection.onRequest(_lspProtocol().RequestDocumentDiagnostics, async uri => {
       let graph = await bundleGraph;
       if (!graph) return;
+
+      // @ts-expect-error TS2345
       return getDiagnosticsUnusedExports(graph, uri);
     });
     connection.onRequest(_lspProtocol().RequestImporters, async params => {
       let graph = await bundleGraph;
       if (!graph) return null;
+
+      // @ts-expect-error TS2345
       return getImporters(graph, params);
     });
     sendDiagnostics();
@@ -179,6 +194,7 @@ var _default = exports.default = new (_plugin().Reporter)({
       watchStarted = true;
     }
     if (watchStarted && lspStarted) {
+      // @ts-expect-error TS7005
       if (!watchStartPromise) {
         watchStartPromise = doWatchStart(options);
       }
@@ -211,7 +227,9 @@ var _default = exports.default = new (_plugin().Reporter)({
           break;
         }
       case 'log':
-        if (event.diagnostics != null && (event.level === 'error' || event.level === 'warn' || event.level === 'info' || event.level === 'verbose')) {
+        if (
+        // @ts-expect-error TS2339
+        event.diagnostics != null && (event.level === 'error' || event.level === 'warn' || event.level === 'info' || event.level === 'verbose')) {
           updateDiagnostics(event.diagnostics, event.level, options.projectRoot);
         }
         break;
@@ -225,6 +243,7 @@ var _default = exports.default = new (_plugin().Reporter)({
         }
       case 'watchEnd':
         connections.forEach(c => c.end());
+        // @ts-expect-error TS7005
         await server.close();
         ignoreFail(() => _fs().default.unlinkSync(META_FILE));
         break;
@@ -261,6 +280,8 @@ function updateDiagnostics(parcelDiagnostics, parcelSeverity, projectRoot) {
     if (firstFrameHighlight == null) {
       continue;
     }
+
+    // @ts-expect-error TS2304
     const relatedInformation = [];
     for (const codeFrame of codeFrames) {
       for (const highlight of codeFrame.codeHighlights) {
@@ -314,6 +335,7 @@ function getDiagnosticsUnusedExports(bundleGraph, document) {
     }
   });
   if (asset) {
+    // @ts-expect-error TS2304
     const generateDiagnostic = (loc, type) => ({
       range: {
         start: {
@@ -330,8 +352,11 @@ function getDiagnosticsUnusedExports(bundleGraph, document) {
       message: `Unused ${type}.`,
       tags: [_utils2.DiagnosticTag.Unnecessary]
     });
+
+    // @ts-expect-error TS2345
     let usedSymbols = bundleGraph.getUsedSymbols(asset);
     if (usedSymbols) {
+      // @ts-expect-error TS2339
       for (let [exported, symbol] of asset.symbols) {
         if (!usedSymbols.has(exported)) {
           if (symbol.loc) {
@@ -358,6 +383,7 @@ function getDiagnosticsUnusedExports(bundleGraph, document) {
       // }
     }
 
+    // @ts-expect-error TS2339
     for (let dep of asset.getDependencies()) {
       let usedSymbols = bundleGraph.getUsedSymbols(dep);
       if (usedSymbols) {
@@ -421,6 +447,7 @@ function getImporters(bundleGraph, document) {
     }
   });
   if (asset) {
+    // @ts-expect-error TS2345
     let incoming = bundleGraph.getIncomingDependencies(asset);
     return incoming.filter(dep => dep.sourcePath != null).map(dep => `file://${(0, _nullthrows().default)(dep.sourcePath)}`);
   }