chore: add no-top-level-arrow-syntax rule to Deno Style Guide linter plugin

_tools/lint_plugin.ts

@@ -56,6 +56,30 @@
         };
       },
     },
+    // https://docs.deno.com/runtime/contributing/style_guide/#top-level-functions-should-not-use-arrow-syntax
+    "no-top-level-arrow-syntax": {
+      create(context) {
+        return {
+          ArrowFunctionExpression(node) {
+            if (
+              node.parent.type === "VariableDeclarator" &&
+              node.parent.parent.type === "VariableDeclaration" &&
+              (node.parent.parent.parent.type === "Program" ||
+                node.parent.parent.parent.type === "ExportNamedDeclaration")
+            ) {
+              // TODO(iuioiua): add fix
+              context.report({
+                node,
+                range: node.range,
+                message: "Top-level functions should not use arrow syntax",
+                hint:
+                  "Use function declaration instead of arrow function. E.g. Use `function foo() {}` instead of `const foo = () => {}`.",
+              });
+            }
+          },
+        };
+      },
+    },
     // https://docs.deno.com/runtime/contributing/style_guide/#do-not-depend-on-external-code.
     "no-external-code": {
       create(context) {

_tools/lint_plugin_test.ts

@@ -56,6 +56,47 @@ class MyClass {
   );
 });
 
+Deno.test("deno-style-guide/no-top-level-arrow-syntax", {
+  ignore: !Deno.version.deno.startsWith("2"),
+}, () => {
+  // Bad
+  assertLintPluginDiagnostics(
+    `
+const foo = () => "bar";
+export const bar = () => "foo";
+    `,
+    [
+      {
+        id: "deno-style-guide/no-top-level-arrow-syntax",
+        range: [13, 24],
+        fix: [],
+        message: "Top-level functions should not use arrow syntax",
+        hint:
+          "Use function declaration instead of arrow function. E.g. Use `function foo() {}` instead of `const foo = () => {}`.",
+      },
+      {
+        id: "deno-style-guide/no-top-level-arrow-syntax",
+        range: [45, 56],
+        fix: [],
+        message: "Top-level functions should not use arrow syntax",
+        hint:
+          "Use function declaration instead of arrow function. E.g. Use `function foo() {}` instead of `const foo = () => {}`.",
+      },
+    ],
+  );
+
+  // Good
+  assertLintPluginDiagnostics(
+    `
+function foo() {
+  const bar = () => "baz";
+
+  return "bar";
+}`,
+    [],
+  );
+});
+
 Deno.test("deno-style-guide/no-external-code", {
   ignore: !Deno.version.deno.startsWith("2"),
 }, () => {

assert/equals_test.ts

@@ -9,22 +9,26 @@ import {
   yellow,
 } from "@std/internal/styles";
 
-const createHeader = (): string[] => [
-  "",
-  "",
-  `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
-    green(
-      bold("Expected"),
-    )
-  }`,
-  "",
-  "",
-];
+function createHeader(): string[] {
+  return [
+    "",
+    "",
+    `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
+      green(
+        bold("Expected"),
+      )
+    }`,
+    "",
+    "",
+  ];
+}
 
-const added: (s: string) => string = (s: string): string =>
-  green(bold(stripAnsiCode(s)));
-const removed: (s: string) => string = (s: string): string =>
-  red(bold(stripAnsiCode(s)));
+function added(s: string): string {
+  return green(bold(stripAnsiCode(s)));
+}
+function removed(s: string): string {
+  return red(bold(stripAnsiCode(s)));
+}
 
 Deno.test({
   name: "assertEquals() matches when values are equal",

expect/_assert_equals_test.ts

@@ -6,22 +6,26 @@ import { AssertionError, assertThrows } from "@std/assert";
 import { bold, gray, green, red, stripAnsiCode, yellow } from "@std/fmt/colors";
 import { assertEquals } from "./_assert_equals.ts";
 
-const createHeader = (): string[] => [
-  "",
-  "",
-  `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
-    green(
-      bold("Expected"),
-    )
-  }`,
-  "",
-  "",
-];
+function createHeader(): string[] {
+  return [
+    "",
+    "",
+    `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
+      green(
+        bold("Expected"),
+      )
+    }`,
+    "",
+    "",
+  ];
+}
 
-const added: (s: string) => string = (s: string): string =>
-  green(bold(stripAnsiCode(s)));
-const removed: (s: string) => string = (s: string): string =>
-  red(bold(stripAnsiCode(s)));
+function added(s: string): string {
+  return green(bold(stripAnsiCode(s)));
+}
+function removed(s: string): string {
+  return red(bold(stripAnsiCode(s)));
+}
 
 Deno.test({
   name: "assertEquals() matches when values are equal",

expect/_extend_test.ts

@@ -28,7 +28,7 @@ class Book {
   }
 }
 
-const areAuthorsEqual: Tester = (a: unknown, b: unknown) => {
+function areAuthorsEqual(a: unknown, b: unknown) {
   const isAAuthor = a instanceof Author;
   const isBAuthor = b instanceof Author;
 
@@ -39,7 +39,7 @@ const areAuthorsEqual: Tester = (a: unknown, b: unknown) => {
   } else {
     return false;
   }
-};
+}
 
 const areBooksEqual: Tester = function (
   this: MatcherContext,

expect/_to_equal_test.ts

@@ -4,22 +4,26 @@ import { bold, gray, green, red, stripAnsiCode, yellow } from "@std/fmt/colors";
 import { AssertionError, assertThrows } from "@std/assert";
 import { expect } from "./expect.ts";
 
-const createHeader = (): string[] => [
-  "",
-  "",
-  `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
-    green(
-      bold("Expected"),
-    )
-  }`,
-  "",
-  "",
-];
+function createHeader(): string[] {
+  return [
+    "",
+    "",
+    `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
+      green(
+        bold("Expected"),
+      )
+    }`,
+    "",
+    "",
+  ];
+}
 
-const added: (s: string) => string = (s: string): string =>
-  green(bold(stripAnsiCode(s)));
-const removed: (s: string) => string = (s: string): string =>
-  red(bold(stripAnsiCode(s)));
+function added(s: string): string {
+  return green(bold(stripAnsiCode(s)));
+}
+function removed(s: string): string {
+  return red(bold(stripAnsiCode(s)));
+}
 
 Deno.test({
   name: "expect().toEqual() matches when values are equal",

fs/_map_error.ts

@@ -6,20 +6,22 @@
 
 type ClassOrT<T> = T extends Class<infer U> ? U : T;
 
-const mapper = (Ctor: typeof errors[keyof typeof errors]) => (err: Error) =>
-  Object.assign(new Ctor(err.message), {
-    stack: err.stack,
-  }) as unknown as ClassOrT<typeof Ctor>;
+function mapper(Ctor: typeof errors[keyof typeof errors]) {
+  return (err: Error) =>
+    Object.assign(new Ctor(err.message), {
+      stack: err.stack,
+    }) as unknown as ClassOrT<typeof Ctor>;
+}
 
 const map: Record<string, ReturnType<typeof mapper>> = {
   EEXIST: mapper(errors.AlreadyExists),
   ENOENT: mapper(errors.NotFound),
   EBADF: mapper(errors.BadResource),
 };
 
-const isNodeErr = (e: unknown): e is Error & { code: string } => {
+function isNodeErr(e: unknown): e is Error & { code: string } {
   return e instanceof Error && "code" in e;
-};
+}
 
 export function mapError<E>(e: E) {
   if (!isNodeErr(e)) return e;

ini/stringify.ts

@@ -36,11 +36,11 @@ function isPlainObject(object: unknown): object is object {
   return Object.prototype.toString.call(object) === "[object Object]";
 }
 
-const sort = ([_a, valA]: [string, unknown], [_b, valB]: [string, unknown]) => {
+function sort([_a, valA]: [string, unknown], [_b, valB]: [string, unknown]) {
   if (isPlainObject(valA)) return 1;
   if (isPlainObject(valB)) return -1;
   return 0;
-};
+}
 
 function defaultReplacer(_key: string, value: unknown, _section?: string) {
   return `${value}`;

log/base_handler.ts

@@ -17,8 +17,10 @@ export type { LevelName, LogLevel, LogRecord };
  * @returns A string representation of the log record.
  */
 export type FormatterFunction = (logRecord: LogRecord) => string;
-const DEFAULT_FORMATTER: FormatterFunction = ({ levelName, msg }) =>
-  `${levelName} ${msg}`;
+// deno-lint-ignore deno-style-guide/naming-convention
+function DEFAULT_FORMATTER(logRecord: LogRecord): string {
+  return `${logRecord.levelName} ${logRecord.msg}`;
+}
 
 /** Options for {@linkcode BaseHandler}. */
 export interface BaseHandlerOptions {

log/formatters_test.ts

@@ -4,13 +4,14 @@ import { FakeTime } from "@std/testing/time";
 import { jsonFormatter } from "./formatters.ts";
 import { LogRecord } from "./logger.ts";
 
-const log = (msg: string, args: unknown[] = []) =>
-  new LogRecord({
+function log(msg: string, args: unknown[] = []) {
+  return new LogRecord({
     msg,
     args,
     level: 20,
     loggerName: "user-logger",
   });
+}
 
 Deno.test("jsonFormatter() handles messages without arguments", function () {
   using _time = new FakeTime(1);