update

Author: axetroy

README.md

@@ -139,6 +139,8 @@ console.log("concat Array", M.concat([1, 2], [2, 3]));
 
 - `deno.unstable` - If Deno's unstable mode is enabled. Default is `false`
 
+- `deno.lint` - If Deno's lint is enabled. `deno.unstable = true` is required. Default is `false`
+
 We recommend that you do not set global configuration. It should be configured in `.vscode/settings.json` in the project directory:
 
 ```json5
@@ -164,6 +166,19 @@ This extension also provides Deno's formatting tools, settings are in `.vscode/s
 }
 ```
 
+This extension also provides Deno's lint tools, settings are in `.vscode/settings.json`:
+
+NOTE: Since Lint is still an experimental feature, So you need to set `deno.unstable = true`. And this function may change in the future.
+
+```json5
+// .vscode/settings.json
+{
+  "deno.enable": true,
+  "deno.unstable": true,
+  "deno.lint": true,
+}
+```
+
 ## Contribute
 
 Follow these steps to contribute, the community needs your strength.

client/src/extension.ts

@@ -20,6 +20,7 @@ import {
   TextDocument,
   languages,
   env,
+  Position,
 } from "vscode";
 import {
   LanguageClient,
@@ -356,29 +357,39 @@ Executable ${this.denoInfo.executablePath}`;
     [command: string]: (
       editor: TextEditor,
       text: string,
-      range: Range
+      range: Range,
+      ...args: unknown[]
     ) => void | Promise<void>;
   }) {
     for (const command in map) {
       const handler = map[command];
-      this.registerCommand(command, async (uri: string, range: Range) => {
-        const textEditor = window.activeTextEditor;
+      this.registerCommand(
+        command,
+        async (uri: string, range: Range, ...args: unknown[]) => {
+          const textEditor = window.activeTextEditor;
 
-        if (!textEditor || textEditor.document.uri.toString() !== uri) {
-          return;
-        }
+          if (!textEditor || textEditor.document.uri.toString() !== uri) {
+            return;
+          }
 
-        range = new Range(
-          range.start.line,
-          range.start.character,
-          range.end.line,
-          range.end.character
-        );
+          range = new Range(
+            range.start.line,
+            range.start.character,
+            range.end.line,
+            range.end.character
+          );
 
-        const rangeText = textEditor.document.getText(range);
+          const rangeText = textEditor.document.getText(range);
 
-        return await handler.call(this, textEditor, rangeText, range);
-      });
+          return await handler.call(
+            this,
+            textEditor,
+            rangeText,
+            range,
+            ...args
+          );
+        }
+      );
     }
   }
   // update diagnostic for a Document
@@ -596,6 +607,33 @@ Executable ${this.denoInfo.executablePath}`;
 
         this.updateDiagnostic(editor.document.uri);
       },
+      _ignore_text_line_lint: async (editor, _, range, rule: unknown) => {
+        editor.edit((edit) => {
+          const currentLineText = editor.document.lineAt(range.start.line);
+          const lastLineText = editor.document.lineAt(range.start.line - 1);
+
+          const offsetEmpty =
+            currentLineText.text.length - currentLineText.text.trim().length;
+
+          edit.replace(
+            lastLineText.range,
+            lastLineText.text +
+              "\n" +
+              `${" ".repeat(offsetEmpty)}// deno-lint-ignore-next-line ${rule}`
+          );
+        });
+        return;
+      },
+      _ignore_entry_file: async (editor) => {
+        editor.edit((edit) => {
+          const firstLineText = editor.document.lineAt(0);
+          edit.insert(
+            new Position(0, 0),
+            "// deno-lint-ignore-file" + (firstLineText.text ? "\n" : "")
+          );
+        });
+        return;
+      },
     });
 
     this.watchConfiguration(() => {

server/src/deno.ts

@@ -3,6 +3,7 @@ import { Readable } from "stream";
 import execa from "execa";
 import which from "which";
 import * as semver from "semver";
+import { Cache } from "../../core/cache";
 
 type Version = {
   deno: string;
@@ -15,16 +16,19 @@ type FormatOptions = {
   cwd: string;
 };
 
+interface LintLocation {
+  line: number; // one base number
+  col: number; // zero base number
+}
+
 interface LintDiagnostic {
-  location: {
-    filename: string;
-    line: number;
-    col: number;
-  };
-  message: string;
   code: string;
-  line_src: string;
-  snippet_length: number;
+  filename: string;
+  message: string;
+  range: {
+    start: LintLocation;
+    end: LintLocation;
+  };
 }
 
 interface LintError {
@@ -37,6 +41,9 @@ interface LintOutput {
   errors: LintError[];
 }
 
+// caching Deno lint's rules for 120s or 100 referenced times
+const denoLintRulesCache = Cache.create<string[]>(1000 * 120, 100);
+
 class Deno {
   public version!: Version | void;
   public executablePath!: string | void;
@@ -55,25 +62,23 @@ class Deno {
       return;
     }
 
-    // If the currently used Deno is less than 0.33.0
+    // If the currently used Deno is less than 1.3.3
     // We will give an warning to upgrade.
-    const minimumDenoVersion = "0.35.0";
+    const minimumDenoVersion = "1.3.3";
     if (!semver.gte(this.version.deno, minimumDenoVersion)) {
       throw new Error(`Please upgrade to Deno ${minimumDenoVersion} or above.`);
     }
   }
   public async getTypes(unstable: boolean): Promise<Buffer> {
     const { stdout } = await execa(this.executablePath as string, [
       "types",
-      ...(unstable && this.version && semver.gte(this.version.deno, "0.43.0")
-        ? ["--unstable"]
-        : []),
+      ...(unstable ? ["--unstable"] : []),
     ]);
 
     return Buffer.from(stdout, "utf8");
   }
   // format code
-  // echo "console.log(123)" | deno fmt --stdin
+  // echo "console.log(123)" | deno fmt -
   public async format(code: string, options: FormatOptions): Promise<string> {
     const reader = Readable.from([code]);
 
@@ -94,54 +99,66 @@ class Deno {
           resolve(stdout);
         }
       });
-      subprocess.on("error", (err: Error) => {
-        reject(err);
-      });
-      subprocess.stdout?.on("data", (data: Buffer) => {
-        stdout += data;
-      });
-
-      subprocess.stderr?.on("data", (data: Buffer) => {
-        stderr += data;
-      });
-
+      subprocess.on("error", (err: Error) => reject(err));
+      subprocess.stdout?.on("data", (data: Buffer) => (stdout += data));
+      subprocess.stderr?.on("data", (data: Buffer) => (stderr += data));
       subprocess.stdin && reader.pipe(subprocess.stdin);
     })) as string;
 
     return formattedCode;
   }
 
-  // TODO: We should read the file content from stdin
-  public async lintFile(filepath: string): Promise<LintOutput> {
+  public async getLintRules(): Promise<string[]> {
+    const cachedRules = denoLintRulesCache.get();
+    if (cachedRules) {
+      return cachedRules;
+    }
     const subprocess = execa(
       this.executablePath as string,
-      ["lint", "--unstable", "--json", filepath],
+      ["lint", "--unstable", "--rules"],
       {
         stdout: "pipe",
-        stderr: "pipe",
       }
     );
 
     const output = await new Promise<string>((resolve, reject) => {
       let stdout = "";
-      let stderr = "";
-      subprocess.on("exit", (exitCode: number) => {
-        if (exitCode !== 0) {
-          resolve(stderr);
-        } else {
-          resolve(stdout);
-        }
-      });
-      subprocess.on("error", (err: Error) => {
-        reject(err);
-      });
-      subprocess.stdout?.on("data", (data: Buffer) => {
-        stdout += data;
-      });
+      subprocess.on("exit", () => resolve(stdout));
+      subprocess.on("error", (err: Error) => reject(err));
+      subprocess.stdout?.on("data", (data: Buffer) => (stdout += data));
+    });
 
-      subprocess.stderr?.on("data", (data: Buffer) => {
-        stderr += data;
-      });
+    const rules = output
+      .split("\n")
+      .map((v) => v.trim())
+      .filter((v) => v.startsWith("-"))
+      .map((v) => v.replace(/^-\s+/, ""));
+
+    denoLintRulesCache.set(rules);
+
+    return rules;
+  }
+
+  // lint code
+  // echo "console.log(123)" | deno lint --unstable --json -
+  public async lint(code: string): Promise<LintOutput> {
+    const reader = Readable.from([code]);
+
+    const subprocess = execa(
+      this.executablePath as string,
+      ["lint", "--unstable", "--json", "-"],
+      {
+        stdin: "pipe",
+        stderr: "pipe",
+      }
+    );
+
+    const output = await new Promise<string>((resolve, reject) => {
+      let stderr = "";
+      subprocess.on("exit", () => resolve(stderr));
+      subprocess.on("error", (err: Error) => reject(err));
+      subprocess.stderr?.on("data", (data: Buffer) => (stderr += data));
+      subprocess.stdin && reader.pipe(subprocess.stdin);
     });
 
     return JSON.parse(output) as LintOutput;