major restructure; split rules into seperate files

Author: meowbmw

.c8rc.json

@@ -1,11 +1,7 @@
 {
   "all": true,
   "include": [
-    "dist/plugins/**/*.js"
-  ],
-  "exclude": [
-    "tests/**",
-    "node_modules/**"
+    "dist/plugins/rules/**/*.js"
   ],
   "reporter": ["text", "html", "lcov"],
   "report-dir": "./coverage",

.github/workflows/ci.yml

@@ -17,5 +17,14 @@ jobs:
       - name: Install dependencies
         run: npm install
 
-      - name: Run test script
-        run: bash ./sanity-check.sh
+      - name: Run build
+        run: npm run build
+
+      - name: Run spell check
+        run: npm run spell-check
+
+      - name: Run prettier
+        run: npm run prettier-check
+
+      - name: Run test & coverage
+        run: npm run test:coverage

.gitignore

@@ -3,4 +3,6 @@ node_modules
 dist/
 sample_cases/
 wasm-toolchain
-coverage
+coverage
+.vscode/settings.json
+reference

package.json

@@ -32,6 +32,7 @@
     "lint": "npx eslint sample_cases/",
     "watch": "npx tsc --build ./tsconfig.json --watch",
     "spell-check": "cspell \"**/*.{ts,js,md}\"",
+    "prettier-check": "prettier --check \"**/*.{ts,js,json,md}\"",
     "prettier-fix": "prettier --check --write \"**/*.{ts,js,json,md}\""
   },
   "peerDependencies": {

plugins/as-plugin.ts

@@ -1,187 +1,17 @@
-import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
-import { RuleListener, RuleModule } from "@typescript-eslint/utils/ts-eslint";
-
 /**
- * ESlint plugin to enforce people to comply with our code guidelines
- * Reference: https://developer.bmwgroup.net/docs/cdc/cdc-platform-wasm/guidelines/#cdc-specific-rules
+ * AssemblyScript ESLint Plugin
+ *
+ * This plugin provides rules for validating AssemblyScript code.
+ * It detects patterns that are either not supported in AssemblyScript
+ * or violate best practices specific to the language.
  */
-
-const createRule = ESLintUtils.RuleCreator(
-  (name) => `https://example.com/rule/${name}`
-);
-
-const dontOmitElse: RuleModule<"omittedElse", [], unknown, RuleListener> =
-  createRule({
-    name: "dont-omit-else",
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "Enforce else block unless if branch contains control flow",
-      },
-      messages: {
-        omittedElse:
-          "Omitted else block is not allowed unless if branch contains control flow.",
-      },
-      schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-      // Check if the statement is part of an else-if chain
-      function isElseIf(node: TSESTree.Node) {
-        // Check parent relationship to determine if this is an else-if
-        const ancestors = context.sourceCode.getAncestors(node);
-        const parent = ancestors[ancestors.length - 1];
-        return (
-          parent && parent.type === "IfStatement" && parent.alternate === node
-        );
-      }
-
-      // Helper function to check if a node is a control flow statement
-      function isControlFlowStatement(
-        node: TSESTree.Node | null | undefined
-      ): boolean {
-        // Return true if the node is a control flow statement
-        return (
-          node?.type === "ReturnStatement" ||
-          node?.type === "ThrowStatement" ||
-          node?.type === "BreakStatement" ||
-          node?.type === "ContinueStatement"
-        );
-      }
-
-      // Check if statement or block contains control flow
-      function checkControlFlow(node: TSESTree.Node) {
-        // Handle different statement types
-        if (node.type === "BlockStatement") {
-          // For block statements, check the last statement in the block
-          const lastStatement =
-            node.body.length > 0 ? node.body[node.body.length - 1] : null;
-          return isControlFlowStatement(lastStatement);
-        } else {
-          // For single statements (no curly braces), check the statement directly
-          return isControlFlowStatement(node);
-        }
-      }
-
-      return {
-        IfStatement(node) {
-          // Skip if this is already an else-if
-          if (isElseIf(node)) {
-            return;
-          }
-          const hasElse = node.alternate !== null;
-          const ifBlockEndsWithControlFlow = checkControlFlow(node.consequent);
-          // Report error if no else and no control flow
-          if (!hasElse && !ifBlockEndsWithControlFlow) {
-            context.report({
-              node,
-              messageId: "omittedElse",
-            });
-          }
-        },
-      };
-    },
-  });
-
-// reject usages of ...var: T on function definition
-const noRestParam: ESLintUtils.RuleModule<
-  "noRestMsg",
-  [],
-  unknown,
-  ESLintUtils.RuleListener
-> = createRule({
-  name: "no-rest-params",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Rest params are not supported.",
-    },
-    messages: {
-      noRestMsg: "Don't use rest params, it's not supported in assemblyscript",
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      RestElement: (node) => {
-        context.report({
-          messageId: "noRestMsg",
-          node: node,
-        });
-      },
-    };
-  },
-});
-
-// reject usages of ...var on call expressions
-const noSpread: ESLintUtils.RuleModule<
-  "noSpreadMsg",
-  [],
-  unknown,
-  ESLintUtils.RuleListener
-> = createRule({
-  name: "no-spread",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Spreads are not supported.",
-    },
-    messages: {
-      noSpreadMsg: "Spreads are not supported.",
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      SpreadElement: (node) => {
-        context.report({ messageId: "noSpreadMsg", node: node });
-      },
-    };
-  },
-});
-
-const noUnsupportedKeyword: ESLintUtils.RuleModule<
-  string,
-  [],
-  unknown,
-  ESLintUtils.RuleListener
-> = createRule({
-  name: "no-unsupported-keyword",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Some keywords are not supported in assemblyscript",
-    },
-    messages: {
-      noNever: "'never' is not supported in AssemblyScript.",
-      noAny: "'any' is not supported in AssemblyScript.",
-      noUndefined: "'undefined' is not supported in AssemblyScript.",
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      TSNeverKeyword: (node) => {
-        context.report({ messageId: "noNever", node: node });
-      },
-      TSAnyKeyword: (node) => {
-        context.report({ messageId: "noAny", node: node });
-      },
-      TSUndefinedKeyword: (node) => {
-        context.report({ messageId: "noUndefined", node: node });
-      },
-    };
-  },
-});
+import dontOmitElse from "./rules/dont-omit-else.js";
+import noSpread from "./rules/no-spread.js";
+import noUnsupportedKeyword from "./rules/no-unsupported-keyword.js";
 
 export default {
   rules: {
     "dont-omit-else": dontOmitElse,
-    "no-rest-params": noRestParam,
     "no-spread": noSpread,
     "no-unsupported-keyword": noUnsupportedKeyword,
   },

plugins/perf-plugin.ts

@@ -1,83 +1,10 @@
-import {
-  AST_NODE_TYPES,
-  ESLintUtils,
-  TSESTree,
-} from "@typescript-eslint/utils";
-
-/**
- * ESlint plugin to detect possible issues that can have impact on performance
- * Reference: https://atc.bmwgroup.net/confluence/display/CDCDEV/AssemblyScript+Performance+Improvement
- */
-const createRule = ESLintUtils.RuleCreator(
-  (name) => `https://example.com/rule/${name}`
-);
-
 /**
- * Rule: Array Initializer
- * Avoid using [] to initialize variables
- * [] will create a temporary object in data section.
- * BAD
- * let v: i32[] = [];
- * GOOD
- * let v: i32[] = new Array();
+ * Performance ESLint Plugin for AssemblyScript
+ *
+ * This plugin provides rules for detecting and fixing potential performance issues
+ * in AssemblyScript code.
  */
-const arrayInitStyle: ESLintUtils.RuleModule<
-  "preferArrayConstructor",
-  [],
-  unknown,
-  ESLintUtils.RuleListener
-> = createRule({
-  name: "array-init-style",
-  meta: {
-    type: "problem",
-    fixable: "code",
-    docs: {
-      description: "Enforce using Array constructor for empty arrays",
-    },
-    messages: {
-      preferArrayConstructor:
-        "Please use new Array<{{ type }}>() to initialize an array",
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      VariableDeclarator(node) {
-        const typeAnnotation = node.id.typeAnnotation?.typeAnnotation;
-        if (
-          typeAnnotation?.type === "TSArrayType" &&
-          typeAnnotation.elementType?.type === "TSTypeReference"
-        ) {
-          if (
-            node.init?.type === "ArrayExpression" &&
-            node.init.elements.length === 0
-          ) {
-            // Ensure node.init is not null before passing to fixer
-            const initNode = node.init;
-            const elementType = context.sourceCode.getText(
-              typeAnnotation.elementType.typeName
-            );
-            context.report({
-              node,
-              messageId: "preferArrayConstructor",
-              data: {
-                type: elementType,
-              },
-              fix(fixer) {
-                // initNode is guaranteed non-null here due to the outer check
-                return fixer.replaceText(
-                  initNode,
-                  `new Array<${elementType}>()`
-                );
-              },
-            });
-          }
-        }
-      },
-    };
-  },
-});
+import arrayInitStyle from "./rules/array-init-style.js";
 
 export default {
   rules: {