Adapt New Rules To Old Rules

eng/tools/typespec-validation/package.json

@@ -1,4 +1,4 @@
 {
   "name": "@azure-tools/typespec-validation",
   "private": true,
   "type": "module",
@@ -10,13 +10,16 @@
     "globby": "^14.0.1",
     "simple-git": "^3.24.0",
     "suppressions": "file:../suppressions",
-    "yaml": "^2.4.2"
+    "yaml": "^2.4.2",
+    "ajv": "^8.17.1",
+    "yaml-eslint-parser": "^1.2.3"
   },
   "devDependencies": {
     "@types/node": "^18.19.31",
     "@vitest/coverage-v8": "^3.0.2",
     "typescript": "~5.6.2",
-    "vitest": "^3.0.2"
+    "vitest": "^3.0.2",
+    "eslint": "^9.17.0"
   },
   "scripts": {
     "build": "tsc --build",

eng/tools/typespec-validation/src/eslint-plugin-tsv/src/config/config-schema.ts

@@ -0,0 +1,117 @@
+// Copied from https://github.com/microsoft/typespec/blob/main/packages/compiler/src/config/config-schema.ts
+
+import type { JSONSchemaType } from "ajv";
+import { EmitterOptions, TypeSpecRawConfig } from "./types.js";
+
+export const emitterOptionsSchema: JSONSchemaType<EmitterOptions> = {
+  type: "object",
+  additionalProperties: true,
+  required: [],
+  properties: {
+    "emitter-output-dir": { type: "string", nullable: true } as any,
+  },
+};
+
+export const TypeSpecConfigJsonSchema: JSONSchemaType<TypeSpecRawConfig> = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    extends: {
+      type: "string",
+      nullable: true,
+    },
+    "environment-variables": {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: {
+        type: "object",
+        properties: {
+          default: { type: "string" },
+        },
+        required: ["default"],
+      },
+    },
+    parameters: {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: {
+        type: "object",
+        properties: {
+          default: { type: "string" },
+        },
+        required: ["default"],
+      },
+    },
+
+    "output-dir": {
+      type: "string",
+      nullable: true,
+    },
+    "warn-as-error": {
+      type: "boolean",
+      nullable: true,
+    },
+    trace: {
+      oneOf: [
+        { type: "string" },
+        {
+          type: "array",
+          items: { type: "string" },
+        },
+      ],
+    } as any, // Issue with AJV optional property typing https://github.com/ajv-validator/ajv/issues/1664
+    imports: {
+      type: "array",
+      nullable: true,
+      items: { type: "string" },
+    },
+    emit: {
+      type: "array",
+      nullable: true,
+      items: { type: "string" },
+    },
+    options: {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: emitterOptionsSchema,
+    },
+    emitters: {
+      type: "object",
+      nullable: true,
+      deprecated: true,
+      required: [],
+      additionalProperties: {
+        oneOf: [{ type: "boolean" }, emitterOptionsSchema],
+      },
+    },
+
+    linter: {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: false,
+      properties: {
+        extends: {
+          type: "array",
+          nullable: true,
+          items: { type: "string" },
+        },
+        enable: {
+          type: "object",
+          required: [],
+          nullable: true,
+          additionalProperties: { type: "boolean" },
+        },
+        disable: {
+          type: "object",
+          required: [],
+          nullable: true,
+          additionalProperties: { type: "string" },
+        },
+      },
+    } as any, // ajv type system doesn't like the string templates
+  },
+};

eng/tools/typespec-validation/src/eslint-plugin-tsv/src/config/types.ts

@@ -0,0 +1,112 @@
+// Copied from https://github.com/microsoft/typespec/blob/main/packages/compiler/src/config/types.ts
+
+import type { Diagnostic, RuleRef } from "@typespec/compiler";
+import type { YamlScript } from "../yaml/types.js";
+
+/**
+ * Represent the normalized user configuration.
+ */
+export interface TypeSpecConfig {
+  /**
+   * Project root.
+   */
+  projectRoot: string;
+
+  /** Yaml file used in this configuration. */
+  file?: YamlScript;
+
+  /**
+   * Path to the config file used to create this configuration.
+   */
+  filename?: string;
+
+  /**
+   * Diagnostics reported while loading the configuration
+   */
+  diagnostics: Diagnostic[];
+
+  /**
+   * Path to another TypeSpec config to extend.
+   */
+  extends?: string;
+
+  /**
+   * Environment variables configuration
+   */
+  environmentVariables?: Record<string, ConfigEnvironmentVariable>;
+
+  /**
+   * Parameters that can be used
+   */
+  parameters?: Record<string, ConfigParameter>;
+
+  /**
+   * Treat warning as error.
+   */
+  warnAsError?: boolean;
+
+  /**
+   * Output directory
+   */
+  outputDir: string;
+
+  /**
+   * Trace options.
+   */
+  trace?: string[];
+
+  /**
+   * Additional imports.
+   */
+  imports?: string[];
+
+  /**
+   * Name of emitters or path to emitters that should be used.
+   */
+  emit?: string[];
+
+  /**
+   * Name of emitters or path to emitters that should be used.
+   */
+  options?: Record<string, EmitterOptions>;
+
+  linter?: LinterConfig;
+}
+
+/**
+ * Represent the configuration that can be provided in a config file.
+ */
+export interface TypeSpecRawConfig {
+  extends?: string;
+  "environment-variables"?: Record<string, ConfigEnvironmentVariable>;
+  parameters?: Record<string, ConfigParameter>;
+
+  "warn-as-error"?: boolean;
+  "output-dir"?: string;
+  trace?: string | string[];
+  imports?: string[];
+
+  emit?: string[];
+  options?: Record<string, EmitterOptions>;
+  emitters?: Record<string, boolean | EmitterOptions>;
+
+  linter?: LinterConfig;
+}
+
+export interface ConfigEnvironmentVariable {
+  default: string;
+}
+
+export interface ConfigParameter {
+  default: string;
+}
+
+export type EmitterOptions = Record<string, unknown> & {
+  "emitter-output-dir"?: string;
+};
+
+export interface LinterConfig {
+  extends?: RuleRef[];
+  enable?: Record<RuleRef, boolean>;
+  disable?: Record<RuleRef, string>;
+}

eng/tools/typespec-validation/src/eslint-plugin-tsv/src/eslint-plugin-tsv.ts

@@ -0,0 +1,27 @@
+import parser from "yaml-eslint-parser";
+import { NamedESLint } from "./interfaces/named-eslint.js";
+import tspconfigValidationRules from "./rules/tspconfig-validation-rules.js";
+
+const plugin: NamedESLint.Plugin = {
+  configs: { recommended: {} },
+  name: "tsv",
+  rules: {},
+};
+
+plugin.configs.recommended = {
+  plugins: {
+    [plugin.name]: plugin,
+  },
+  files: ["*.yaml", "**/*.yaml"],
+  rules: {},
+  languageOptions: {
+    parser: parser,
+  },
+};
+
+tspconfigValidationRules.forEach((rule) => {
+  plugin.rules![rule.name] = rule;
+  plugin.configs.recommended.rules![`${plugin.name}/${rule.name}`] = "error";
+});
+
+export default plugin;

eng/tools/typespec-validation/src/eslint-plugin-tsv/src/interfaces/named-eslint.ts

@@ -0,0 +1,17 @@
+import { ESLint, Linter, Rule } from "eslint";
+
+// ESLint with names for convenience
+
+export namespace NamedRule {
+  export interface RuleModule extends Rule.RuleModule {
+    name: string;
+  }
+}
+
+export namespace NamedESLint {
+  export interface Plugin extends ESLint.Plugin {
+    configs: { recommended: Linter.Config };
+    name: string;
+    rules?: Record<string, NamedRule.RuleModule>;
+  }
+}

eng/tools/typespec-validation/src/eslint-plugin-tsv/src/interfaces/rule-interfaces.ts

@@ -0,0 +1,34 @@
+import { Rule } from "eslint";
+import { TypeSpecConfig } from "../config/types.js";
+
+export enum KeyType {
+  EmitterOption,
+  Parameter,
+}
+
+export interface RuleDocument {
+  description: string;
+  error: string;
+  action: string;
+  example: string;
+}
+
+export interface RuleInfo {
+  name: string;
+  documentation: RuleDocument;
+  functions: {
+    messages: () => { [messageId: string]: string } | undefined;
+    condition: (tspconfig: TypeSpecConfig, context: Rule.RuleContext) => boolean;
+    validation: (tspconfig: TypeSpecConfig, context: Rule.RuleContext, node: Rule.Node) => void;
+  };
+}
+
+export interface CreateCodeGenSDKRuleArgs {
+  rule: string;
+  type: KeyType;
+  key: string;
+  expectedValue: string | boolean | RegExp;
+  exampleValue: string | boolean;
+  extraExplanation?: string;
+  condition?: (tspconfig: TypeSpecConfig, context: Rule.RuleContext) => boolean;
+}