feat: ban type assertions (as + angle-bracket), as const allowed

Author: Hiro5409

.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
+      - run: deno fmt --check
+      - run: deno lint
+      - run: deno test
+      - run: deno publish --dry-run

.github/workflows/publish.yml

@@ -0,0 +1,16 @@
+name: Publish
+on:
+  workflow_dispatch: {}
+permissions:
+  contents: read
+  id-token: write
+jobs:
+  publish:
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
+      - run: deno publish

.gitignore

@@ -0,0 +1,2 @@
+coverage/
+.DS_Store

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hiro5409
+
+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.

README.md

@@ -0,0 +1,55 @@
+# @hiro5409/deno-no-type-assertion-lint
+
+Deno lint plugin that forbids TypeScript type assertions (`as` and angle-bracket
+syntax). `as const` / `<const>` is allowed.
+
+Inspired by `@typescript-eslint/consistent-type-assertions` (`assertionStyle: "never"`)
+and `oxc/consistent-type-assertions` (error message), implemented as a native Deno lint plugin.
+
+## Install
+
+Requires Deno 2.2.0 or newer.
+
+```jsonc
+// deno.json
+{
+  "lint": {
+    "plugins": ["jsr:@hiro5409/deno-no-type-assertion-lint"]
+  }
+}
+```
+
+## Why?
+
+Type assertions tell TypeScript to trust you instead of proving the type. They
+can hide real type errors, especially around object literals, DOM APIs, and
+untyped data.
+
+This rule nudges code toward:
+
+- explicit type annotations
+- `satisfies` for shape checking
+- type guards when runtime narrowing is actually needed
+
+## Examples
+
+```typescript
+// Bad
+const canvas = document.getElementById("c") as HTMLCanvasElement;
+const name = <string> data.name;
+
+// Good
+const canvas: HTMLCanvasElement | null = document.querySelector("canvas");
+const config = { mode: "dark" } satisfies AppConfig;
+```
+
+## Ignoring a report
+
+```typescript
+// deno-lint-ignore no-type-assertion/no-type-assertion -- API returns untyped JSON
+const data = await response.json() as UserProfile;
+```
+
+## License
+
+MIT

deno.json

@@ -0,0 +1,28 @@
+{
+  "name": "@hiro5409/deno-no-type-assertion-lint",
+  "version": "0.1.0",
+  "license": "MIT",
+  "exports": "./mod.ts",
+  "publish": {
+    "include": ["LICENSE", "README.md", "deno.json", "mod.ts"]
+  },
+  "imports": {
+    "@std/assert": "jsr:@std/assert@1"
+  },
+  "tasks": {
+    "test": "deno test",
+    "check": "deno publish --dry-run"
+  },
+  "lint": {
+    "plugins": ["./mod.ts"]
+  },
+  "compilerOptions": {
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "erasableSyntaxOnly": true
+  },
+  "lock": false
+}

mod.ts

@@ -0,0 +1,59 @@
+/**
+ * Deno lint plugin that forbids TypeScript type assertions (`as` and angle-bracket).
+ * `as const` / `<const>` is allowed.
+ *
+ * Inspired by `@typescript-eslint/consistent-type-assertions` (`assertionStyle: "never"`)
+ * and `oxc/consistent-type-assertions` (error message), implemented as a native Deno lint plugin.
+ *
+ * @example
+ * ```jsonc
+ * // deno.json
+ * {
+ *   "lint": {
+ *     "plugins": ["jsr:@hiro5409/deno-no-type-assertion-lint"]
+ *   }
+ * }
+ * ```
+ *
+ * @module
+ */
+
+/** Whether a type annotation node is `const` (for `as const` / `<const>`). */
+function isConst(
+  ta: { type: string; typeName?: { type: string; name?: string } },
+): boolean {
+  return ta.type === "TSTypeReference" &&
+    ta.typeName?.type === "Identifier" &&
+    ta.typeName.name === "const";
+}
+
+const MESSAGE =
+  "Do not use any type assertions. Use a type annotation or `satisfies` operator instead.";
+
+/**
+ * The lint plugin instance.
+ *
+ * Rules:
+ * - `no-type-assertion/no-type-assertion` — Bans type assertions (`as const` / `<const>` allowed)
+ */
+const plugin: Deno.lint.Plugin = {
+  name: "no-type-assertion",
+  rules: {
+    "no-type-assertion": {
+      create(context) {
+        return {
+          TSAsExpression(node) {
+            if (isConst(node.typeAnnotation)) return;
+            context.report({ node, message: MESSAGE });
+          },
+          TSTypeAssertion(node) {
+            if (isConst(node.typeAnnotation)) return;
+            context.report({ node, message: MESSAGE });
+          },
+        };
+      },
+    },
+  },
+};
+
+export default plugin;

mod_test.ts

@@ -0,0 +1,98 @@
+import { assertEquals, assertExists } from "@std/assert";
+import plugin from "./mod.ts";
+
+Deno.test("reports `as` type assertion", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = "hello" as unknown;`,
+  );
+  assertEquals(d.length, 1);
+  const diag = d[0];
+  assertExists(diag);
+  assertEquals(diag.id, "no-type-assertion/no-type-assertion");
+  assertEquals(
+    diag.message,
+    "Do not use any type assertions. Use a type annotation or `satisfies` operator instead.",
+  );
+});
+
+Deno.test("reports angle-bracket type assertion", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = <string>"hello";`,
+  );
+  assertEquals(d.length, 1);
+  const diag = d[0];
+  assertExists(diag);
+  assertEquals(diag.id, "no-type-assertion/no-type-assertion");
+});
+
+Deno.test("allows `as const`", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = "hello" as const;`,
+  );
+  assertEquals(d.length, 0);
+});
+
+Deno.test("allows `<const>`", () => {
+  const d = Deno.lint.runPlugin(plugin, "test.ts", `const x = <const>"hello";`);
+  assertEquals(d.length, 0);
+});
+
+Deno.test("allows type annotations", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x: string = "hello";`,
+  );
+  assertEquals(d.length, 0);
+});
+
+Deno.test("allows `satisfies`", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = "hello" satisfies string;`,
+  );
+  assertEquals(d.length, 0);
+});
+
+Deno.test("reports nested `as` assertion", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = (obj as any).foo;`,
+  );
+  assertEquals(d.length, 1);
+});
+
+Deno.test("reports double assertion (as unknown as T)", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = value as unknown as string;`,
+  );
+  assertEquals(d.length, 2);
+});
+
+Deno.test("reports generic angle-bracket assertion", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = <Array<string>>value;`,
+  );
+  assertEquals(d.length, 1);
+});
+
+Deno.test("allows `as const satisfies`", () => {
+  const d = Deno.lint.runPlugin(
+    plugin,
+    "test.ts",
+    `const x = { a: 1 } as const satisfies { a: number };`,
+  );
+  assertEquals(d.length, 0);
+});