Feat: Enhance rule set (#4)

New Rules Added:

    no-concat-string Rule:
        Prohibits string concatenation inside loops to avoid performance issues caused by repeated memory allocation and garbage collection. Suggests alternatives like array.join() or string builders. [1] [2]
    specify-type Rule:
        Enforces explicit type annotations for variable declarations, especially for numeric types, to enhance WebAssembly type safety and performance. [1] [2]

Author: xpirad

.prettierignore

@@ -2,7 +2,6 @@
 dist/**
 reference/**
 sample_cases/**
-sample_config/**
 build/**
 wasm-toolchain/**
 coverage/**

cspell/project-words.txt

@@ -17,6 +17,7 @@ typechecker
 tsconfig
 tseslint
 tses
+sonarjs
 
 // AssemblyScript types and keywords
 i8

docs/rules/no-concat-string.md

@@ -0,0 +1,65 @@
+# no-concat-string
+
+> Disallow string concatenation in loops
+
+## Rule Details
+
+String concatenation inside loops can lead to performance issues in AssemblyScript. Each concatenation operation creates a new string object, which can cause memory allocation overhead and garbage collection pressure in tight loops. This rule enforces using alternative approaches like array joining or string builders for better performance.
+
+## Rule Options
+
+This rule has no configuration options.
+
+## Examples
+
+### Incorrect
+
+```ts
+// String concatenation with + operator in loop
+for (let i = 0; i < 1000; i++) {
+  const message = "Count: " + i; // not recommended
+}
+
+// String concatenation with += operator in loop
+let result = "";
+for (let i = 0; i < 1000; i++) {
+  result += "Item " + i; // not recommended
+}
+
+// String methods used in concatenation
+let formatted = "";
+for (let i = 0; i < items.length; i++) {
+  formatted += text.toUpperCase() + " "; // not recommended
+}
+
+// Object property string concatenation
+const obj = { message: "" };
+for (let i = 0; i < 10; i++) {
+  obj.message += "test"; // not recommended
+}
+```
+
+### Correct
+
+```ts
+// Use array join for better performance
+const parts: string[] = [];
+for (let i = 0; i < 1000; i++) {
+  // add items to parts
+  // ...
+}
+const result = parts.join("");
+
+// String concatenation outside loops is allowed
+const greeting = "Hello " + name;
+
+// String operations that don't involve concatenation
+for (let i = 0; i < items.length; i++) {
+  const formatted = items[i].toString();
+  console.log(formatted);
+}
+```
+
+## When Not To Use
+
+If you're not concerned about performance in specific use cases or working with very small loops where the performance impact is negligible, you might choose to disable this rule. However, it's generally recommended to follow this rule for better performance.

docs/rules/specify-type.md

@@ -0,0 +1,58 @@
+# specify-type
+
+> Enforce explicit type annotations for variable declarations
+
+## Rule Details
+
+This rule enforces explicit type annotations for:
+
+1. **Floating point literals** - default inferred float type f64 might not always be the optimal choice, and should be specified explicitly (f32 or f64)
+2. **Uninitialized variables** - to ensure type safety
+
+Integer literals are allowed to use AssemblyScript's default type inference (which infers `i32`), as this is typically the desired behavior and maintains good ergonomics.
+
+## Rule Options
+
+This rule has no configuration options.
+
+## Examples
+
+### Incorrect
+
+```ts
+// Missing type annotation for floating-point literal
+const mileage = 5.3; // requires explicit f32 or f64 annotation
+
+// No type annotation and no initialization
+let count; // missing type annotation
+
+// Array with floating-point literals without type annotation
+const scores = [75.5, 82.3, 90.1]; // requires explicit type annotation
+```
+
+### Correct
+
+```ts
+// Explicit type annotation for floating-point values
+const mileage: f32 = 5.3; // recommended - specifies precision
+const pi: f64 = 3.14159; // or f64 for double precision
+
+// Explicit type annotation when no initialization
+let count: i32; // recommended
+
+// Array with explicit type annotation
+const scores: f32[] = [75.5, 82.3, 90.1]; // recommended
+const numbers: i32[] = new Array<i32>(); // recommended
+
+// Integer literals and const variables with non-numeric types (type can be inferred)
+const numbers = [1, 2, 3]; // allowed - integers default to i32
+const count = 42; // allowed - integer defaults to i32
+const message = "hello"; // allowed - string literals
+const isValid = true; // allowed - boolean literals
+```
+
+## Rationale
+
+- **WebAssembly Type Safety**: AssemblyScript assigns float variable default to f64, and may not always be optimal
+- **Numeric Type Distinction**: JavaScript numbers don't distinguish between f32 and f64, so explicit typing is crucial for performance
+- **Code Clarity**: Explicit types make the intended floating point precision clear to developers

package.json

@@ -33,7 +33,7 @@
   ],
   "scripts": {
     "build": "npx tsc --build ./tsconfig.json",
-    "test": "mocha 'dist/tests/**/**.test.js'",
+    "test": "mocha --timeout 10000 'dist/tests/**/**.test.js'",
     "test:coverage": "c8 npm test",
     "lint": "npx eslint plugins/ tests/",
     "watch": "npx tsc --build ./tsconfig.json --watch",

plugins/asPlugin.ts

@@ -6,13 +6,17 @@
  * or violate best practices specific to the language.
  */
 import dontOmitElse from "./rules/dontOmitElse.js";
+import noConcatString from "./rules/noConcatString.js";
 import noSpread from "./rules/noSpread.js";
 import noUnsupportedKeyword from "./rules/noUnsupportedKeyword.js";
+import specifyType from "./rules/specifyType.js";
 
 export default {
   rules: {
     "dont-omit-else": dontOmitElse,
     "no-spread": noSpread,
     "no-unsupported-keyword": noUnsupportedKeyword,
+    "specify-type": specifyType,
+    "no-concat-string": noConcatString,
   },
 };

plugins/rules/arrayInitStyle.ts

@@ -5,10 +5,6 @@ import createRule from "../utils/createRule.js";
  * 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();
  */
 const arrayInitStyle: ESLintUtils.RuleModule<
   "preferArrayConstructor",

plugins/rules/dontOmitElse.ts

@@ -5,10 +5,6 @@ import createRule from "../utils/createRule.js";
 /**
  * Rule: Dont Omit Else
  * Enforce using else block when if branch doesn't contain control flow statement.
- * BAD
- * if (x) { }
- * GOOD
- * if (x) { } else { }
  */
 
 // Helper function to check if a node will lead to early exit

plugins/rules/noConcatString.ts

@@ -0,0 +1,151 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import createRule from "../utils/createRule.js";
+import ts from "typescript";
+
+/**
+ * Rule: Don't allow string concatenation in loops as this can incur performance penalties.
+ */
+
+export default createRule({
+  name: "no-concat-string",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow string concatenation in loops",
+    },
+    messages: {
+      noConcatInLoop:
+        "String concatenation inside loops can lead to performance issues. Use array.join() or a string builder instead.",
+    },
+    schema: [], // no options
+  },
+  defaultOptions: [],
+  create(context) {
+    // We uses built-in type system to deduce type information
+    // https://typescript-eslint.io/developers/custom-rules/#typed-rules
+    // https://typescript-eslint.io/getting-started/typed-linting/
+    function isStringType(type: ts.Type): boolean {
+      // basic string type
+      if (type.flags & ts.TypeFlags.String) {
+        return true;
+      }
+
+      // String literal type (e.g., 'hello')
+      if (type.flags & ts.TypeFlags.StringLiteral) {
+        return true;
+      }
+
+      // Template literal type (e.g., `hello${string}`)
+      if (type.flags & ts.TypeFlags.TemplateLiteral) {
+        return true;
+      }
+
+      // String in union type (e.g., string | number)
+      if (type.isUnion()) {
+        return type.types.some((t) => isStringType(t));
+      }
+
+      // Type alias (e.g., type MyString = string)
+      if (type.aliasSymbol) {
+        return isStringType(checker.getDeclaredTypeOfSymbol(type.aliasSymbol));
+      }
+
+      return false;
+    }
+    // Track the loop nesting level
+    let loopDepth = 0;
+    // Grab the parser services for the rule
+    const parserServices = ESLintUtils.getParserServices(context);
+    // Grab the TypeScript type checker
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      // Track entry and exit for loops
+      // Upon entering, loopDepth will increment; upon exiting loopDepth will decrease
+      // We use this mechanism to detect whether we are in a loop or not (when in loop, loopDepth will be a value greater than 0)
+      ForStatement() {
+        loopDepth++;
+      },
+      "ForStatement:exit"() {
+        loopDepth--;
+      },
+
+      WhileStatement() {
+        loopDepth++;
+      },
+      "WhileStatement:exit"() {
+        loopDepth--;
+      },
+
+      DoWhileStatement() {
+        loopDepth++;
+      },
+      "DoWhileStatement:exit"() {
+        loopDepth--;
+      },
+
+      ForInStatement() {
+        loopDepth++;
+      },
+      "ForInStatement:exit"() {
+        loopDepth--;
+      },
+
+      ForOfStatement() {
+        loopDepth++;
+      },
+      "ForOfStatement:exit"() {
+        loopDepth--;
+      },
+
+      // Check for string concatenation with + operator
+      BinaryExpression(node) {
+        // Only check inside loops
+        if (loopDepth === 0) return;
+
+        const leftType: ts.Type = parserServices.getTypeAtLocation(node.left);
+        const rightType: ts.Type = parserServices.getTypeAtLocation(node.right);
+
+        if (
+          node.operator === "+" &&
+          (isStringType(leftType) || isStringType(rightType))
+        ) {
+          context.report({
+            node,
+            messageId: "noConcatInLoop",
+          });
+        }
+      },
+
+      // Check for string concatenation with += operator
+      AssignmentExpression(node) {
+        if (loopDepth === 0) {
+          return;
+        }
+
+        if (node.operator === "+=") {
+          // Check if right side is a string type
+          const rightType: ts.Type = parserServices.getTypeAtLocation(
+            node.right
+          );
+
+          const rightIsString = isStringType(rightType);
+          const leftType: ts.Type = parserServices.getTypeAtLocation(node.left);
+          const leftIsString = isStringType(leftType);
+
+          // Check different left side patterns
+          let shouldReport = false;
+
+          shouldReport = leftIsString || rightIsString;
+
+          if (shouldReport) {
+            context.report({
+              node,
+              messageId: "noConcatInLoop",
+            });
+          }
+        }
+      },
+    };
+  },
+});

plugins/rules/noSpread.ts

@@ -3,12 +3,7 @@ import createRule from "../utils/createRule.js";
 
 /**
  * Rule: No Spread
- * Reject usages of ...var on call expressions, as spread syntax
- * is not supported in AssemblyScript.
- * BAD:
- * foo(1, ...bar)
- * GOOD:
- * foo(1, bar)
+ * Reject usages of ...var on call expressions, as spread syntax is not supported in AssemblyScript.
  */
 const noSpread: ESLintUtils.RuleModule<
   "noSpreadMsg",