feat: More lint rules (#2153)

Author: aleksanderkatan

packages/eslint-plugin/src/configs.ts

@@ -1,20 +1,28 @@
 import type { TSESLint } from '@typescript-eslint/utils';
 import { integerDivision } from './rules/integerDivision.ts';
 import { unwrappedPojos } from './rules/unwrappedPojos.ts';
+import { math } from './rules/math.ts';
+import { uninitializedVariable } from './rules/uninitializedVariable.ts';
 
 export const rules = {
   'integer-division': integerDivision,
   'unwrapped-pojo': unwrappedPojos,
+  'uninitialized-variable': uninitializedVariable,
+  math: math,
 } as const;
 
 type Rules = Record<`typegpu/${keyof typeof rules}`, TSESLint.FlatConfig.RuleEntry>;
 
 export const recommendedRules: Rules = {
   'typegpu/integer-division': 'warn',
   'typegpu/unwrapped-pojo': 'warn',
+  'typegpu/uninitialized-variable': 'warn',
+  'typegpu/math': 'warn',
 };
 
 export const allRules: Rules = {
   'typegpu/integer-division': 'error',
   'typegpu/unwrapped-pojo': 'error',
+  'typegpu/uninitialized-variable': 'error',
+  'typegpu/math': 'error',
 };

packages/eslint-plugin/src/rules/math.ts

@@ -0,0 +1,56 @@
+import { createRule } from '../ruleCreator.ts';
+import { enhanceRule } from '../enhanceRule.ts';
+import { directiveTracking } from '../enhancers/directiveTracking.ts';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+import { ASTUtils, type TSESTree } from '@typescript-eslint/utils';
+
+export const math = createRule({
+  name: 'math',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: `Disallow usage of JavaScript 'Math' methods inside 'use gpu' functions; use 'std' instead.`,
+    },
+    messages: {
+      math: "Using Math methods, such as '{{snippet}}', is not advised, and may not work as expected. Use 'std' instead.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+
+  create: enhanceRule({ directives: directiveTracking }, (context, state) => {
+    const { directives } = state;
+
+    return {
+      CallExpression(node) {
+        if (!directives.insideUseGpu()) {
+          return;
+        }
+
+        if (
+          node.callee.type === 'MemberExpression' &&
+          node.callee.object.type === 'Identifier' &&
+          node.callee.object.name === 'Math' &&
+          isGlobalIdentifier(context, node.callee.object)
+        ) {
+          context.report({
+            node,
+            messageId: 'math',
+            data: { snippet: context.sourceCode.getText(node) },
+          });
+        }
+      },
+    };
+  }),
+});
+
+function isGlobalIdentifier(
+  context: Readonly<RuleContext<string, unknown[]>>,
+  node: TSESTree.Identifier,
+) {
+  const variable = ASTUtils.findVariable(context.sourceCode.getScope(node), node);
+  if (!variable) {
+    throw new Error(`Couldn't find variable ${node.name}.`);
+  }
+  return variable.defs.length === 0;
+}

packages/eslint-plugin/src/rules/uninitializedVariable.ts

@@ -0,0 +1,41 @@
+import { enhanceRule } from '../enhanceRule.ts';
+import { directiveTracking } from '../enhancers/directiveTracking.ts';
+import { createRule } from '../ruleCreator.ts';
+
+export const uninitializedVariable = createRule({
+  name: 'uninitialized-variable',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Always assign an initial value when declaring a variable inside TypeGPU functions.`,
+    },
+    messages: {
+      uninitializedVariable: "'{{snippet}}' should have an initial value.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+
+  create: enhanceRule({ directives: directiveTracking }, (context, state) => {
+    const { directives } = state;
+
+    return {
+      VariableDeclarator(node) {
+        if (!directives.insideUseGpu()) {
+          return;
+        }
+        if (node.parent?.parent?.type === 'ForOfStatement') {
+          // one exception where we allow uninitialized variable
+          return;
+        }
+        if (node.init === null) {
+          context.report({
+            node,
+            messageId: 'uninitializedVariable',
+            data: { snippet: context.sourceCode.getText(node) },
+          });
+        }
+      },
+    };
+  }),
+});

packages/eslint-plugin/tests/math.test.ts

@@ -0,0 +1,26 @@
+import { describe } from 'vitest';
+import { ruleTester } from './ruleTester.ts';
+import { math } from '../src/rules/math.ts';
+
+describe('math', () => {
+  ruleTester.run('math', math, {
+    valid: [
+      'const result = Math.sin(1);',
+      'const t = std.sin(Math.PI)',
+      "const fn = () => { 'use gpu'; const vec = std.sin(Math.PI); }",
+      "const Math = { sin: std.sin }; const fn = () => { 'use gpu'; const vec = Math.sin(0); }",
+      "import Math from 'utils'; const fn = () => { 'use gpu'; const vec = Math.sin(0); }",
+    ],
+    invalid: [
+      {
+        code: "const fn = () => { 'use gpu'; const vec = Math.sin(0); }",
+        errors: [
+          {
+            messageId: 'math',
+            data: { snippet: 'Math.sin(0)' },
+          },
+        ],
+      },
+    ],
+  });
+});

packages/eslint-plugin/tests/uninitializedVariable.test.ts

@@ -0,0 +1,44 @@
+import { describe } from 'vitest';
+import { ruleTester } from './ruleTester.ts';
+import { uninitializedVariable } from '../src/rules/uninitializedVariable.ts';
+
+describe('uninitializedVariable', () => {
+  ruleTester.run('uninitializedVariable', uninitializedVariable, {
+    valid: [
+      'let a;',
+      'let a, b;',
+      "const fn = () => { 'use gpu'; const vec = d.vec3f(); }",
+      "const fn = () => { 'use gpu'; let vec = d.vec3f(); }",
+      `const fn = () => { 'use gpu';
+        let a = 0;
+        for (const foo of tgpu.unroll([1, 2, 3])) {
+          a += foo;
+        }
+      }`,
+    ],
+    invalid: [
+      {
+        code: "const fn = () => { 'use gpu'; let vec; }",
+        errors: [
+          {
+            messageId: 'uninitializedVariable',
+            data: { snippet: 'vec' },
+          },
+        ],
+      },
+      {
+        code: "const fn = () => { 'use gpu'; let a = 1, b, c = d.vec3f(), d; }",
+        errors: [
+          {
+            messageId: 'uninitializedVariable',
+            data: { snippet: 'b' },
+          },
+          {
+            messageId: 'uninitializedVariable',
+            data: { snippet: 'd' },
+          },
+        ],
+      },
+    ],
+  });
+});

packages/typegpu/tests/jsMath.test.ts

@@ -19,6 +19,7 @@ describe('Math', () => {
     const myFn = () => {
       'use gpu';
       const a = 0.5;
+      // oxlint-disable-next-line typegpu/math
       const b = Math.sin(a);
     };
 
@@ -33,6 +34,7 @@ describe('Math', () => {
   it('precomputes Math.sin when applicable', () => {
     const myFn = () => {
       'use gpu';
+      // oxlint-disable-next-line typegpu/math
       const a = Math.sin(0.5);
     };
 
@@ -47,6 +49,7 @@ describe('Math', () => {
     const myFn = () => {
       'use gpu';
       const a = d.u32();
+      // oxlint-disable-next-line typegpu/math
       const b = Math.sin(a);
     };
 
@@ -62,6 +65,7 @@ describe('Math', () => {
     const myFn = () => {
       'use gpu';
       const a = d.u32();
+      // oxlint-disable-next-line typegpu/math
       const b = Math.min(a, 1, 2, 3);
     };
 
@@ -76,6 +80,7 @@ describe('Math', () => {
   it('throws a readable error when unsupported Math feature is used', () => {
     const myFn = () => {
       'use gpu';
+      // oxlint-disable-next-line typegpu/math
       const a = Math.log1p(1);
     };
 
@@ -90,6 +95,7 @@ describe('Math', () => {
   it('correctly applies Math.fround', () => {
     const myFn = () => {
       'use gpu';
+      // oxlint-disable-next-line typegpu/math
       const a = Math.fround(16777217);
     };