Add invalid-node-types rule

Author: JoshMock

specification/eslint.config.js

@@ -13,6 +13,7 @@ export default defineConfig({
   },
   plugins: { 'es-spec-validator': validator },
   rules: {
-    'es-spec-validator/single-key-dictionary-key-is-string': 'error'
+    'es-spec-validator/single-key-dictionary-key-is-string': 'error',
+    'es-spec-validator/invalid-node-types': 'warn',
   }
 })

validator/README.md

@@ -7,7 +7,8 @@ It is configured [in the specification directory](../specification/eslint.config
 
 | Name | Description |
 | - | - |
-| `single-key-dictionary-key-is-string` | `SingleKeyDictionary` keys must be strings |
+| `single-key-dictionary-key-is-string` | `SingleKeyDictionary` keys must be strings. |
+| `invalid-node-types` | The spec uses a subset of TypeScript, so some types, clauses and expressions are not allowed. |
 
 ## Usage
 

validator/eslint-plugin-es-spec.js

@@ -1,7 +1,9 @@
 import singleKeyDict from './rules/single-key-dictionary-key-is-string.js'
+import invalidNodeTypes from './rules/invalid-node-types.js'
 
 export default {
   rules: {
-    'single-key-dictionary-key-is-string': singleKeyDict
+    'single-key-dictionary-key-is-string': singleKeyDict,
+    'invalid-node-types': invalidNodeTypes,
   }
 }

validator/rules/invalid-node-types.js

@@ -0,0 +1,48 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+const createRule = ESLintUtils.RuleCreator(name => `https://example.com/rule/${name}`)
+
+export default createRule({
+  name: 'invalid-node-types',
+  create(context) {
+    return {
+      'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSFunctionType, TSEmptyBodyFunctionExpression, TSDeclareFunction, MethodDefinition'(node) {
+        context.report({ node, messageId: 'function' })
+      },
+      'DoWhileStatement, ForInStatement,  ForOfStatement, ForStatement, WhileStatement'(node) {
+        context.report({ node, messageId: 'loop' })
+      },
+      'CatchClause, ThrowStatement, TryStatement'(node) {
+        context.report({ node, messageId: 'exception' })
+      },
+      'TSAsyncKeyword, AwaitExpression'(node) {
+        context.report({ node, messageId: 'async' })
+      },
+      'SwitchStatement, SwitchCase, ConditionalExpression, IfStatement, TSConditionalType'(node) {
+        context.report({ node, messageId: 'condition' })
+      },
+      TSUndefinedKeyword(node) {
+        context.report({ node, messageId: 'undefined' })
+      },
+      TSNeverKeyword(node) {
+        context.report({ node, messageId: 'never' })
+      },
+    }
+  },
+  meta: {
+    docs: {
+      description: 'The Elasticsearch specification only uses a subset of the TypeScript language, primarily classes, interfaces, enums and type aliases.',
+    },
+    messages: {
+      function: 'Functions are not supported by the Elasticsearch specification',
+      loop: 'Loops are not supported by the Elasticsearch specification',
+      exception: 'Exception management is not supported by the Elasticsearch specification',
+      async: 'Async/await syntax is not supported by the Elasticsearch specification',
+      condition: 'Conditional expressions are not supported by the Elasticsearch specification',
+      undefined: '`undefined` is not a valid type in the Elasticsearch specification',
+      never: '`never` is not a valid type in the Elasticsearch specification',
+    },
+    type: 'suggestion',
+  },
+  defaultOptions: []
+})

validator/test/invalid-node-types.test.js

@@ -0,0 +1,84 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import rule from '../rules/invalid-node-types.js'
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: import.meta.dirname,
+    },
+  },
+})
+
+ruleTester.run('invalid-node-types', rule, {
+  valid: [
+    `type MyType = number`,
+    `enum MyEnum { foo, bar, baz }`,
+    `class MyClass {
+       foo: boolean
+       bar: object
+       baz: any
+    }`,
+    `interface MyInterface {
+  id: number
+  data: object
+  records: Record<string, number[]>[]
+}`
+  ],
+  invalid: [
+    {
+      code: `type MyFn = (name: string) => boolean`,
+      errors: [{ messageId: 'function' }]
+    },
+    {
+      code: `function foo(bar: string): number { return 1 }`,
+      errors: [{ messageId: 'function' }]
+    },
+    {
+      code: `try {
+  doThing()
+} catch (err: any) {
+  logError(err)
+}`,
+      errors: [
+        // two messages because TryStatement and CatchClause get flagged separately
+        { messageId: 'exception' },
+        { messageId: 'exception' },
+      ]
+    },
+    {
+      code: `for (let i = 0; i++; i < 5) { console.log(i) }`,
+      errors: [{ messageId: 'loop' }]
+    },
+    {
+      code: `while (true) { console.log('hello') }`,
+      errors: [{ messageId: 'loop' }]
+    },
+    {
+      code: `for (const i of myArray) { console.log(i) }`,
+      errors: [{ messageId: 'loop' }]
+    },
+    {
+      code: `const val = await myFn()`,
+      errors: [{ messageId: 'async' }]
+    },
+    {
+      code: `if (true) console.log('true!')`,
+      errors: [{ messageId: 'condition' }]
+    },
+    {
+      code: 'const CondType = someCondition ? TypeOne : TypeTwo',
+      errors: [{ messageId: 'condition' }]
+    },
+    {
+      code: 'type Foo = undefined',
+      errors: [{ messageId: 'undefined' }]
+    },
+    {
+      code: 'type Foo = never',
+      errors: [{ messageId: 'never' }]
+    }
+  ],
+})