feat(oxlint-config): add func-style rule

Author: dangreen

packages/oxlint-config/src/plugin/func-style.js

@@ -0,0 +1,154 @@
+function isFunctionExpression(node) {
+  return node?.type === 'ArrowFunctionExpression'
+    || node?.type === 'FunctionExpression'
+}
+
+function pushComputedKeys(stack, classBody) {
+  classBody.body.forEach((member) => {
+    if (member.computed) {
+      stack.push(member.key)
+    }
+  })
+}
+
+function pushChildren(stack, node) {
+  Object.entries(node).forEach(([key, value]) => {
+    if (key === 'parent' || typeof value !== 'object' || value === null) {
+      return
+    }
+
+    if (Array.isArray(value)) {
+      value.forEach(item => stack.push(item))
+    } else {
+      stack.push(value)
+    }
+  })
+}
+
+/**
+ * Check if a function references `this`, `arguments` or `new.target` from its own scope,
+ * so it can't be converted to an arrow function.
+ * @param {object} functionNode
+ * @returns {boolean} Whether the function uses its own bindings.
+ */
+function usesFunctionBindings(functionNode) {
+  const stack = [...functionNode.params, functionNode.body]
+
+  while (stack.length > 0) {
+    const node = stack.pop()
+
+    if (!node || typeof node.type !== 'string') {
+      continue
+    }
+
+    switch (node.type) {
+      case 'ThisExpression':
+        return true
+      case 'MetaProperty':
+        if (node.meta.name === 'new') {
+          return true
+        }
+
+        continue
+      case 'Identifier':
+        if (node.name === 'arguments') {
+          return true
+        }
+
+        continue
+      // nested regular functions and class members rebind `this` and `arguments`
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+        continue
+      case 'ClassBody':
+        pushComputedKeys(stack, node)
+        continue
+      case 'MemberExpression':
+        stack.push(node.object)
+
+        if (node.computed) {
+          stack.push(node.property)
+        }
+
+        continue
+      case 'Property':
+      case 'PropertyDefinition':
+      case 'MethodDefinition':
+        if (node.computed) {
+          stack.push(node.key)
+        }
+
+        stack.push(node.value)
+        continue
+      default:
+        pushChildren(stack, node)
+    }
+  }
+
+  return false
+}
+
+function checkDeclarator(context, declarator) {
+  if (
+    isFunctionExpression(declarator.init)
+    && declarator.id.type === 'Identifier'
+    && !declarator.id.typeAnnotation
+  ) {
+    context.report({
+      node: declarator.id,
+      message: 'Use a function declaration instead of assigning a function to a constant at the top level.'
+    })
+  }
+}
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce function declarations at the top level and arrow functions assigned to constants inside functions.'
+    },
+    schema: []
+  },
+  create(context) {
+    let depth = 0
+
+    return {
+      FunctionDeclaration(node) {
+        if (depth > 0 && !node.generator && !usesFunctionBindings(node)) {
+          context.report({
+            node: node.id ?? node,
+            message: 'Use an arrow function assigned to a constant instead of a nested function declaration.'
+          })
+        }
+
+        depth++
+      },
+      'FunctionDeclaration:exit'() {
+        depth--
+      },
+      FunctionExpression() {
+        depth++
+      },
+      'FunctionExpression:exit'() {
+        depth--
+      },
+      ArrowFunctionExpression() {
+        depth++
+      },
+      'ArrowFunctionExpression:exit'() {
+        depth--
+      },
+      StaticBlock() {
+        depth++
+      },
+      'StaticBlock:exit'() {
+        depth--
+      },
+      VariableDeclaration(node) {
+        if (depth === 0 && node.kind === 'const') {
+          node.declarations.forEach(declarator => checkDeclarator(context, declarator))
+        }
+      }
+    }
+  }
+}

packages/oxlint-config/src/plugin/index.js

@@ -1,4 +1,5 @@
 import extensionsRule from './extensions.js'
+import funcStyleRule from './func-style.js'
 import importOrderRule from './import-order.js'
 import memberOrderingRule from './member-ordering.js'
 import namedExportOrderRule from './named-export-order.js'
@@ -12,6 +13,7 @@ export default {
   },
   rules: {
     'extensions': extensionsRule,
+    'func-style': funcStyleRule,
     'import-order': importOrderRule,
     'member-ordering': memberOrderingRule,
     'named-export-order': namedExportOrderRule,

packages/oxlint-config/src/plugin/naming-convention.js

@@ -224,8 +224,7 @@ export default {
   },
   create(context) {
     const options = context.options
-
-    function check(name, node, selector, modifiers = []) {
+    const check = (name, node, selector, modifiers = []) => {
       const option = getSelectorOptions(options, selector, modifiers)
 
       if (!option || isValidName(name, option)) {
@@ -237,14 +236,12 @@ export default {
         message: `Name "${name}" must match one of these formats: ${getExpectedFormats(option.format)}.`
       })
     }
-
-    function checkPattern(pattern, selector) {
+    const checkPattern = (pattern, selector) => {
       for (const item of getIdentifierNames(pattern)) {
         check(item.name, item.node, selector)
       }
     }
-
-    function checkProperty(node, selector) {
+    const checkProperty = (node, selector) => {
       const name = getKeyName(node.key)
 
       if (name === null) {

packages/oxlint-config/src/subconfigs/basic.js

@@ -223,13 +223,6 @@ export default {
     'eslint/prefer-template': 'error',
     'eslint/symbol-description': 'error',
     'eslint/func-names': 'error',
-    'eslint/func-style': [
-      'error',
-      'declaration',
-      {
-        allowArrowFunctions: true
-      }
-    ],
     'eslint/max-nested-callbacks': ['error', 4],
     'eslint/max-params': ['error', 6],
     'eslint/new-cap': [
@@ -245,6 +238,7 @@ export default {
     'eslint/operator-assignment': ['error', 'always'],
     'eslint/prefer-object-spread': 'error',
     'eslint/unicode-bom': 'error',
+    'trigen/func-style': 'error',
     'trigen/naming-convention': [
       'error',
       {