Deno lsp doesn't report plugin lints if they require runtime permissions

[sigmaSd]

deno.json

{
  "lint": {
    "plugins": [
      "jsr:@sigmasd/deno-no-sync-in-async-lint@0.6.0"
    ]
  }
}

a.ts

function b() {
  Deno.readDirSync("");
}

export async function a() {
  b();
  await Promise.resolve();
}

deno lint a.ts
┏ ⚠️  Deno requests read access to "/HOME/MRCOOL/.CACHE/DENO/NPM/REGISTRY.NPMJS.ORG/TYPESCRIPT/5.7.2/LIB/TYPESCRIPT.JS".
┠─ Requested by `Deno.statSync()` API.
✅ Granted all read access.
┏ ⚠️  Deno requests env access to "TSC_WATCHFILE".
┠─ To see a stack trace for this prompt, set the DENO_TRACE_PERMISSIONS env✅ Granted all env access.
error[sync-checker/no-sync-in-async]: Blocking operation found in async function 'a'
 --> /home/mrcool/dev/deno/lab/pp/a.ts:6:3
  |
6 |   b();
  |   ^^^


Found 1 problem
Checked 1 file

deno lint a.ts works, but the deno lsp doesn't report the lint, presumably because it needs runtime permission (it uses typescript to analyze cross imports functions which require at-least read and env permission)

[sigmaSd]

I updated the plugin here https://jsr.io/@sigmasd/deno-no-sync-in-async-lint

Now I'm done with it I'm going to use the issue to ask a couple of questions:

1. For this issue , its not really a bug but a design decision that needs to be made

   • are you going to allow plugins with permissions ?
   • will deno lint cli command now accept permission flags ?
   • will it need a way for the plugin to declare the permission it uses, or will deno just hardcode some non risky permissions to be allowed like Read and Env

2. Deno lint only give me the current file AST, eslint works the same way , I don't know about biome, but that feels limiting, I don't know if what I'm doing is not that common ? but you can see in this plugin I had to use typescript to parse imported files

   • maybe its a good idea to make the linter gives all imported files AST
   • or at-least give an API function that can parse files to an AST, since I can get imports from ImportDecleartion , I can call that function manually
   • this will be better then what I can achieve with typescript, since in theory it can give me even remote imports AST

3. At some point I needed async create ( I needed to use fetch api in it) I don't know how common this need is though

4. There are bunch of typing issue, also the multiple fixes didn't seem to work when I tested on canary but I can report these issues individually when I can reproduce better

[sigmaSd]

If permissions are allowed it might be possible to replicate no-floating-promises, since in the end it just uses typescirpt, I have a simple script like it

// floating-promises-analyzer.ts
import ts from "npm:typescript@5.7.2";
import * as path from "jsr:@std/path@1.0.8";

interface PromiseLocation {
  file: string;
  line: number;
  column: number;
  expression: string;
}

export interface AnalyzerState {
  floatingPromises: Map<string, PromiseLocation>;
  analyzedFiles: Set<string>;
}

export class TypeScriptAnalyzer {
  private state: AnalyzerState = {
    floatingPromises: new Map<string, PromiseLocation>(),
    analyzedFiles: new Set<string>(),
  };

  private program?: ts.Program;

  private createProgram(rootFiles: string[]): ts.Program {
    const compilerOptions: ts.CompilerOptions = {
      target: ts.ScriptTarget.Latest,
      module: ts.ModuleKind.ESNext,
      moduleResolution: ts.ModuleResolutionKind.NodeNext,
      allowJs: true,
      checkJs: true,
    };

    return ts.createProgram(rootFiles, compilerOptions);
  }

  private normalizeImportPath(
    importSpecifier: string,
    currentFile: string,
  ): string {
    if (!importSpecifier.startsWith(".")) {
      return importSpecifier;
    }

    const currentDir = path.dirname(currentFile);
    const resolvedPath = path.resolve(currentDir, importSpecifier);
    return /\.[^/.]+$/.test(resolvedPath) ? resolvedPath : `${resolvedPath}.ts`;
  }

  private isPromiseType(node: ts.Node, typeChecker: ts.TypeChecker): boolean {
    const type = typeChecker.getTypeAtLocation(node);
    const symbol = type.getSymbol();
    if (!symbol) return false;

    // Check if it's a Promise type directly
    if (symbol.getName() === "Promise") return true;

    // Check if it has .then property (Promise-like)
    return type.getProperty("then") !== undefined;
  }

  private isPromiseHandled(node: ts.Expression): boolean {
    let current: ts.Node = node;
    while (current.parent) {
      const parent = current.parent;

      // Check if the promise is awaited
      if (ts.isAwaitExpression(parent)) {
        return true;
      }

      // Check if the promise is returned
      if (ts.isReturnStatement(parent)) {
        return true;
      }

      // Check if the promise is assigned to a variable
      if (ts.isVariableDeclaration(parent)) {
        return true;
      }

      // Check if the promise is part of Promise.all/race/any
      if (
        ts.isCallExpression(parent) &&
        ts.isPropertyAccessExpression(parent.expression) &&
        ts.isIdentifier(parent.expression.expression) &&
        parent.expression.expression.text === "Promise" &&
        ["all", "race", "any"].includes(parent.expression.name.text)
      ) {
        return true;
      }

      // Check if the promise is handled by .then() or .catch()
      if (
        ts.isCallExpression(parent) &&
        ts.isPropertyAccessExpression(parent.expression) &&
        ["then", "catch", "finally"].includes(parent.expression.name.text)
      ) {
        return true;
      }

      current = parent;
    }

    return false;
  }

  private analyzeSourceFile(
    sourceFile: ts.SourceFile,
    filePath: string,
    typeChecker: ts.TypeChecker,
  ) {
    const visit = (node: ts.Node) => {
      // Check expressions that might return promises
      if (ts.isExpressionStatement(node)) {
        const expr = node.expression;
        if (
          (ts.isCallExpression(expr) || ts.isAwaitExpression(expr)) &&
          this.isPromiseType(expr, typeChecker) &&
          !this.isPromiseHandled(expr)
        ) {
          const { line, character } = sourceFile.getLineAndCharacterOfPosition(
            node.getStart(),
          );
          const location: PromiseLocation = {
            file: filePath,
            line: line + 1,
            column: character + 1,
            expression: node.getText(),
          };

          const locationKey =
            `${location.file}:${location.line}:${location.column}`;
          this.state.floatingPromises.set(locationKey, location);
        }
      }

      ts.forEachChild(node, visit);
    };

    ts.forEachChild(sourceFile, visit);
  }

  analyzeFile(filePath: string) {
    const absolutePath = path.resolve(filePath);

    if (this.state.analyzedFiles.has(absolutePath)) {
      return;
    }

    this.state.analyzedFiles.add(absolutePath);

    try {
      // Create or get the TypeScript program
      if (!this.program) {
        this.program = this.createProgram([absolutePath]);
      }

      const sourceFile = this.program.getSourceFile(absolutePath);
      if (!sourceFile) {
        throw new Error(`Could not get source file for ${absolutePath}`);
      }

      const typeChecker = this.program.getTypeChecker();

      // Analyze imports first
      const analyzeImports = (node: ts.Node) => {
        if (ts.isImportDeclaration(node)) {
          const source = node.moduleSpecifier.getText().replace(/['"]/g, "");
          if (source.startsWith(".")) {
            const importPath = this.normalizeImportPath(source, absolutePath);
            this.analyzeFile(importPath);
          }
        }
      };

      ts.forEachChild(sourceFile, analyzeImports);

      // Analyze the file for floating promises
      this.analyzeSourceFile(sourceFile, absolutePath, typeChecker);
    } catch (error) {
      if (error instanceof Deno.errors.NotFound) {
        console.error(`Skipping analyzing ${absolutePath}: File not found`);
      } else {
        console.error(`Error analyzing ${absolutePath}:`, error);
      }
    }
  }

  getState(): AnalyzerState {
    return this.state;
  }
}

if (import.meta.main) {
  const analyzer = new TypeScriptAnalyzer();
  const filePath = Deno.args[0];
  if (!filePath) {
    console.error("Please provide a file path to analyze");
    Deno.exit(1);
  }

  analyzer.analyzeFile(filePath);
  const state = analyzer.getState();
  const floatingPromises = Array.from(state.floatingPromises.values());

  if (floatingPromises.length > 0) {
    console.log(
      "\nWarning: Found floating promises in the following locations:",
    );
    floatingPromises.forEach((location) => {
      console.log(
        `  - ${location.file}:${location.line}:${location.column}`,
      );
      console.log(`    Expression: ${location.expression}`);
    });
    console.log(
      "\nFloating promises should be handled with await, .then()/.catch(), or stored in a variable.",
    );
  } else {
    console.log("\nNo floating promises found.");
  }
}

[phaux]

It would be nice if plugins had access to ts.Program and a WeakMap of AST nodes to TS nodes (like in typescript-eslint) so we can implement rules based on type info.

In such case there would be no need for file system permissions.