feat: Lint rule for unsupported js

oxlint.config.ts

@@ -2,9 +2,6 @@ import { defineConfig } from 'oxlint';
 import typegpu from 'eslint-plugin-typegpu';
 import eslintPlugin from 'eslint-plugin-eslint-plugin';
 
-const typegpuPreset = typegpu.configs?.recommended;
-const typegpuRules = typegpuPreset && 'rules' in typegpuPreset ? typegpuPreset.rules : {};
-
 export default defineConfig({
   plugins: ['eslint', 'typescript', 'import', 'unicorn', 'oxc'],
   jsPlugins: ['eslint-plugin-typegpu', 'eslint-plugin-eslint-plugin'],
@@ -13,7 +10,7 @@ export default defineConfig({
     suspicious: 'warn',
   },
   rules: {
-    ...typegpuRules,
+    ...typegpu.configs.recommended.rules,
     'typescript/no-unsafe-enum-comparison': 'off',
     'typescript/restrict-template-expressions': 'off',
     'typescript/no-unsafe-type-assertion': 'off',

packages/eslint-plugin/README.md

@@ -46,6 +46,7 @@ export default defineConfig([
 | [no-invalid-assignment](docs/rules/no-invalid-assignment.md)           | Disallow assignments that will generate invalid WGSL                                        | ⭐  |    |
 | [no-math](docs/rules/no-math.md)                                       | Disallow usage of JavaScript 'Math' methods inside 'use gpu' functions                      |    | ⭐  |
 | [no-uninitialized-variables](docs/rules/no-uninitialized-variables.md) | Disallow variable declarations without initializers inside 'use gpu' functions              | ⭐  |    |
+| [no-unsupported-syntax](docs/rules/no-unsupported-syntax.md)           | Disallow JS syntax that will not be parsed to correct WGSL.                                 | ⭐  |    |
 | [no-unwrapped-objects](docs/rules/no-unwrapped-objects.md)             | Disallow unwrapped Plain Old JavaScript Objects inside 'use gpu' functions (except returns) | ⭐  |    |
 
 <!-- end auto-generated rules list -->

packages/eslint-plugin/docs/rules/no-unsupported-syntax.md

@@ -0,0 +1,64 @@
+# typegpu/no-unsupported-syntax
+
+📝 Disallow JS syntax that will not be parsed to correct WGSL.
+
+🚨 This rule is enabled in the ⭐ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const fn = () => { 
+  'use gpu'; 
+  const helper = (n) => 2 * n; // ArrowFunctionExpression
+  return helper(1);
+}
+```
+```ts
+const fn = () => { 
+  'use gpu'; 
+  const myStruct = Struct({prop: 1});
+  const otherStruct = Struct({...myStruct}); // SpreadElement
+  return otherStruct;
+}
+```
+```ts
+const fn = () => { 
+  'use gpu'; 
+  throw new Error(); // ThrowStatement
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const fn = (a) => { 
+  'use gpu';
+  let counter = 0; 
+  let i = a;
+  while (i) {
+    if (i % 2 === 1) {
+      counter += 1;
+    }
+    i >>= 1;
+  }
+  return otherFn(counter);
+} 
+```
+```ts
+const fn = () => { 
+  'use gpu'; 
+  let a = 0;
+  const arr = [1, 2, 3];
+  for (const item of arr) {
+    a += item;
+  }
+  return a;
+} 
+```
+
+Note that it is possible that TypeGPU starts/stops supporting JS syntax from version to version.
+Make sure that the minor versions of `typegpu` and `eslint-plugin-typegpu` match.

packages/eslint-plugin/src/configs.ts

@@ -4,13 +4,15 @@ import { noUnwrappedObjects } from './rules/noUnwrappedObjects.ts';
 import { noMath } from './rules/noMath.ts';
 import { noUninitializedVariables } from './rules/noUninitializedVariables.ts';
 import { noInvalidAssignment } from './rules/noInvalidAssignment.ts';
+import { noUnsupportedSyntax } from './rules/noUnsupportedSyntax.ts';
 
 export const rules = {
   'no-integer-division': noIntegerDivision,
   'no-unwrapped-objects': noUnwrappedObjects,
   'no-uninitialized-variables': noUninitializedVariables,
   'no-math': noMath,
   'no-invalid-assignment': noInvalidAssignment,
+  'no-unsupported-syntax': noUnsupportedSyntax,
 } as const;
 
 type Rules = Record<`typegpu/${keyof typeof rules}`, TSESLint.FlatConfig.RuleEntry>;
@@ -21,6 +23,7 @@ export const recommendedRules: Rules = {
   'typegpu/no-uninitialized-variables': 'error',
   'typegpu/no-math': 'warn',
   'typegpu/no-invalid-assignment': 'error',
+  'typegpu/no-unsupported-syntax': 'error',
 };
 
 export const allRules: Rules = {
@@ -29,4 +32,5 @@ export const allRules: Rules = {
   'typegpu/no-uninitialized-variables': 'error',
   'typegpu/no-math': 'error',
   'typegpu/no-invalid-assignment': 'error',
+  'typegpu/no-unsupported-syntax': 'error',
 };

packages/eslint-plugin/src/enhancers/directiveTracking.ts

@@ -9,6 +9,7 @@ export type FunctionNode =
 
 export type DirectiveData = {
   getEnclosingTypegpuFunction: () => FunctionNode | undefined;
+  getDirectiveStack: () => readonly { node: FunctionNode; directives: string[] }[];
 };
 
 /**
@@ -48,13 +49,16 @@ export const directiveTracking: RuleEnhancer<DirectiveData> = () => {
   return {
     visitors,
     state: {
-      getEnclosingTypegpuFunction: () => {
+      getEnclosingTypegpuFunction() {
         const current = stack.at(-1);
         if (current && current.directives.includes('use gpu')) {
           return current.node;
         }
         return undefined;
       },
+      getDirectiveStack() {
+        return stack;
+      },
     },
   };
 };

packages/eslint-plugin/src/index.ts

@@ -22,7 +22,7 @@ const all: TSESLint.FlatConfig.Config = {
   rules: allRules,
 };
 
-const plugin: TSESLint.FlatConfig.Plugin = {
+const plugin = {
   ...pluginBase,
   configs: {
     recommended,