@sun-asterisk/sunlint 1.0.5

package/eslint-integration/eslint-plugin-custom/c018-no-generic-throw.js

@@ -0,0 +1,335 @@
+/**
+ * Custom ESLint rule for: C018 – Do not throw generic errors, always use specific messages
+ * Rule ID: custom/c018
+ * Purpose: Enforce specific error messages when throwing errors to improve debugging and error handling
+ */
+
+const c018Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Do not throw generic errors, always use specific messages",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowGenericInTests: {
+            type: "boolean",
+            description: "Whether to allow generic throws in test files (default: true)"
+          },
+          allowRethrow: {
+            type: "boolean",
+            description: "Whether to allow rethrowing caught errors (default: true)"
+          },
+          allowThrowVariable: {
+            type: "boolean",
+            description: "Whether to allow throwing variables/identifiers (default: false)"
+          },
+          requiredMessagePatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Regex patterns that error messages must match"
+          },
+          minimumMessageLength: {
+            type: "number",
+            description: "Minimum length for error messages (default: 10)"
+          },
+          allowedGenericMessages: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of allowed generic messages"
+          },
+          customErrorClasses: {
+            type: "array",
+            items: { type: "string" },
+            description: "Custom error class names that are allowed"
+          },
+          strictMode: {
+            type: "boolean",
+            description: "Enable strict mode with additional checks (default: false)"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      genericError: "Do not throw generic errors. Provide a specific error message.",
+      emptyError: "Error message cannot be empty. Provide a specific error message.",
+      messageToolShort: "Error message too short (minimum {{minLength}} characters). Vietnamese: 'Message error quá ngắn (tối thiểu {{minLength}} ký tự)'",
+      genericErrorMessage: "Generic error message '{{message}}' should be more specific. Vietnamese: 'Message error generic nên cụ thể hơn'",
+      throwWithoutMessage: "Throw statement must include a specific error message. Vietnamese: 'Throw statement phải có message error cụ thể'",
+      useSpecificErrorClass: "Use specific error class instead of generic Error. Vietnamese: 'Dùng error class cụ thể thay vì Error generic'",
+      invalidMessagePattern: "Error message doesn't match required patterns. Vietnamese: 'Message error không khớp pattern yêu cầu'",
+      throwBareString: "Throwing bare string is not recommended, use Error object with message. Vietnamese: 'Throw string trực tiếp không khuyến khích, dùng Error object với message'"
+    },
+    fixable: null
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    
+    // Default configuration
+    const allowGenericInTests = options.allowGenericInTests !== false;
+    const allowRethrow = options.allowRethrow !== false;
+    const allowThrowVariable = options.allowThrowVariable || false;
+    const requiredMessagePatterns = options.requiredMessagePatterns || [];
+    const minimumMessageLength = options.minimumMessageLength || 10;
+    const allowedGenericMessages = new Set(options.allowedGenericMessages || []);
+    const customErrorClasses = new Set(options.customErrorClasses || ['ValidationError', 'BusinessError', 'NetworkError', 'AuthenticationError', 'AuthorizationError']);
+    const strictMode = options.strictMode || false;
+
+    const sourceCode = context.getSourceCode();
+    const filename = context.getFilename();
+
+    // Generic error messages to detect
+    const genericMessages = new Set([
+      'error',
+      'Error',
+      'ERROR',
+      'something went wrong',
+      'something failed',
+      'operation failed',
+      'invalid',
+      'invalid input',
+      'bad input',
+      'error occurred',
+      'an error occurred',
+      'failed',
+      'failure',
+      'exception',
+      'unexpected error',
+      'internal error',
+      'system error',
+      'unknown error'
+    ]);
+
+    function isTestFile() {
+      if (!allowGenericInTests) return false;
+      
+      const testPatterns = ['.test.', '.spec.', '__tests__', '/test/', '/tests/', '.e2e.'];
+      return testPatterns.some(pattern => filename.includes(pattern));
+    }
+
+    function isRethrowStatement(node) {
+      if (!allowRethrow) return false;
+
+      // Check if throwing a caught error parameter
+      if (node.argument && node.argument.type === 'Identifier') {
+        // Look for catch clauses in parent scopes
+        let parent = node.parent;
+        while (parent) {
+          if (parent.type === 'CatchClause' && 
+              parent.param && 
+              parent.param.name === node.argument.name) {
+            return true;
+          }
+          parent = parent.parent;
+        }
+      }
+
+      return false;
+    }
+
+    function getErrorMessage(node) {
+      if (!node.argument) return null;
+
+      // Direct string literal
+      if (node.argument.type === 'Literal') {
+        return node.argument.value;
+      }
+
+      // new Error("message")
+      if (node.argument.type === 'NewExpression' && 
+          node.argument.callee && 
+          node.argument.arguments && 
+          node.argument.arguments.length > 0) {
+        const firstArg = node.argument.arguments[0];
+        if (firstArg.type === 'Literal') {
+          return firstArg.value;
+        }
+      }
+
+      return null;
+    }
+
+    function getErrorClassName(node) {
+      if (node.argument && 
+          node.argument.type === 'NewExpression' && 
+          node.argument.callee) {
+        if (node.argument.callee.type === 'Identifier') {
+          return node.argument.callee.name;
+        }
+      }
+      return null;
+    }
+
+    function isGenericErrorMessage(message) {
+      if (typeof message !== 'string') return false;
+      
+      const normalizedMessage = message.toLowerCase().trim();
+      return genericMessages.has(normalizedMessage) || 
+             genericMessages.has(message.trim());
+    }
+
+    function isMessageTooShort(message) {
+      if (typeof message !== 'string') return false;
+      return message.trim().length < minimumMessageLength;
+    }
+
+    function matchesRequiredPatterns(message) {
+      if (requiredMessagePatterns.length === 0) return true;
+      if (typeof message !== 'string') return false;
+      
+      return requiredMessagePatterns.some(pattern => {
+        try {
+          const regex = new RegExp(pattern);
+          return regex.test(message);
+        } catch (e) {
+          return false;
+        }
+      });
+    }
+
+    function isAllowedGenericMessage(message) {
+      if (typeof message !== 'string') return false;
+      return allowedGenericMessages.has(message.trim());
+    }
+
+    function checkThrowStatement(node) {
+      // Skip if in test file and allowed
+      if (isTestFile()) {
+        return;
+      }
+
+      // Skip if this is a rethrow
+      if (isRethrowStatement(node)) {
+        return;
+      }
+
+      // Check for throw without argument
+      if (!node.argument) {
+        context.report({
+          node,
+          messageId: 'throwWithoutMessage'
+        });
+        return;
+      }
+
+      // Check for throwing variables/identifiers
+      if (node.argument.type === 'Identifier' && !allowThrowVariable) {
+        context.report({
+          node,
+          messageId: 'genericError'
+        });
+        return;
+      }
+
+      // Check for throwing bare strings
+      if (node.argument.type === 'Literal' && typeof node.argument.value === 'string') {
+        if (strictMode) {
+          context.report({
+            node,
+            messageId: 'throwBareString'
+          });
+          return;
+        }
+        
+        const message = node.argument.value;
+        validateMessage(node, message);
+        return;
+      }
+
+      // Check for new Error() constructions
+      if (node.argument.type === 'NewExpression') {
+        const errorClassName = getErrorClassName(node);
+        const errorMessage = getErrorMessage(node);
+
+        // Check error class
+        if (strictMode && errorClassName === 'Error') {
+          context.report({
+            node,
+            messageId: 'useSpecificErrorClass'
+          });
+        }
+
+        // Check error message
+        if (errorMessage !== null) {
+          validateMessage(node, errorMessage);
+        } else if (node.argument.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: 'throwWithoutMessage'
+          });
+        }
+        return;
+      }
+
+      // Generic throw statement
+      context.report({
+        node,
+        messageId: 'genericError'
+      });
+    }
+
+    function validateMessage(node, message) {
+      if (!message || typeof message !== 'string') {
+        context.report({
+          node,
+          messageId: 'throwWithoutMessage'
+        });
+        return;
+      }
+
+      // Check for empty or whitespace-only message
+      if (message.trim() === '') {
+        context.report({
+          node,
+          messageId: 'emptyError'
+        });
+        return;
+      }
+
+      // Check if message is allowed generic
+      if (isAllowedGenericMessage(message)) {
+        return;
+      }
+
+      // Check for generic messages
+      if (isGenericErrorMessage(message)) {
+        context.report({
+          node,
+          messageId: 'genericErrorMessage',
+          data: { message: message.trim() }
+        });
+        return;
+      }
+
+      // Check message length
+      if (isMessageTooShort(message)) {
+        context.report({
+          node,
+          messageId: 'messageToolShort',
+          data: { minLength: minimumMessageLength }
+        });
+        return;
+      }
+
+      // Check required patterns
+      if (!matchesRequiredPatterns(message)) {
+        context.report({
+          node,
+          messageId: 'invalidMessagePattern'
+        });
+        return;
+      }
+    }
+
+    return {
+      ThrowStatement: checkThrowStatement
+    };
+  }
+};
+
+module.exports = c018Rule;

package/eslint-integration/eslint-plugin-custom/c023-no-duplicate-variable-name-in-scope.js

@@ -0,0 +1,142 @@
+/**
+ * Custom ESLint rule for: C023 – Do not use duplicate variable names in the same scope
+ * Rule ID: custom/c023
+ * Purpose: Prevent variable name shadowing and maintain clear variable scoping
+ */
+
+const c023Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Do not use duplicate variable names in the same scope",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      duplicateVariable: "Variable '{{name}}' is already declared in this scope"
+    }
+  },
+  create(context) {
+    const scopeStack = [];
+    const variableMap = new Map();
+
+    function enterScope() {
+      scopeStack.push(new Map());
+    }
+
+    function exitScope() {
+      const scope = scopeStack.pop();
+      // Clean up variables from the exited scope
+      for (const [name, info] of scope) {
+        const globalInfo = variableMap.get(name);
+        if (globalInfo) {
+          globalInfo.scopes.delete(scope);
+          if (globalInfo.scopes.size === 0) {
+            variableMap.delete(name);
+          }
+        }
+      }
+    }
+
+    function checkVariable(node, name) {
+      if (scopeStack.length === 0) return;
+
+      const currentScope = scopeStack[scopeStack.length - 1];
+      
+      // Check if variable is already declared in current scope
+      if (currentScope.has(name)) {
+        context.report({
+          node,
+          messageId: "duplicateVariable",
+          data: { name }
+        });
+        return;
+      }
+
+      // Add variable to current scope
+      currentScope.set(name, {
+        node,
+        scopes: new Set([currentScope])
+      });
+
+      // Update global variable map
+      if (!variableMap.has(name)) {
+        variableMap.set(name, {
+          scopes: new Set([currentScope])
+        });
+      } else {
+        variableMap.get(name).scopes.add(currentScope);
+      }
+    }
+
+    return {
+      Program() {
+        enterScope();
+      },
+      "Program:exit"() {
+        exitScope();
+      },
+      FunctionDeclaration() {
+        enterScope();
+      },
+      "FunctionDeclaration:exit"() {
+        exitScope();
+      },
+      FunctionExpression() {
+        enterScope();
+      },
+      "FunctionExpression:exit"() {
+        exitScope();
+      },
+      ArrowFunctionExpression() {
+        enterScope();
+      },
+      "ArrowFunctionExpression:exit"() {
+        exitScope();
+      },
+      BlockStatement() {
+        enterScope();
+      },
+      "BlockStatement:exit"() {
+        exitScope();
+      },
+      CatchClause() {
+        enterScope();
+      },
+      "CatchClause:exit"() {
+        exitScope();
+      },
+      ForStatement() {
+        enterScope();
+      },
+      "ForStatement:exit"() {
+        exitScope();
+      },
+      ForInStatement() {
+        enterScope();
+      },
+      "ForInStatement:exit"() {
+        exitScope();
+      },
+      ForOfStatement() {
+        enterScope();
+      },
+      "ForOfStatement:exit"() {
+        exitScope();
+      },
+      SwitchStatement() {
+        enterScope();
+      },
+      "SwitchStatement:exit"() {
+        exitScope();
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier") {
+          checkVariable(node, node.id.name);
+        }
+      }
+    };
+  }
+};
+
+module.exports = c023Rule;

package/eslint-integration/eslint-plugin-custom/c027-limit-function-nesting.js

@@ -0,0 +1,50 @@
+/**
+ * Custom ESLint rule for: C027 – Avoid deeply nested functions (maximum 2 levels)
+ * Rule ID: custom/c027
+ * Goal: Limit function nesting to maximum 2 levels to improve readability and maintainability
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Avoid deeply nested functions (maximum 2 levels)",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      tooDeep: "Function is nested too deeply (level {{depth}}). Should be maximum 2 levels."
+    }
+  },
+  create(context) {
+    let functionStack = [];
+
+    function enterFunction(node) {
+      functionStack.push(node);
+      const depth = functionStack.length;
+
+      if (depth > 2) {
+        context.report({
+          node,
+          messageId: "tooDeep",
+          data: {
+            depth
+          }
+        });
+      }
+    }
+
+    function exitFunction() {
+      functionStack.pop();
+    }
+
+    return {
+      FunctionDeclaration: enterFunction,
+      FunctionExpression: enterFunction,
+      ArrowFunctionExpression: enterFunction,
+      'FunctionDeclaration:exit': exitFunction,
+      'FunctionExpression:exit': exitFunction,
+      'ArrowFunctionExpression:exit': exitFunction
+    };
+  }
+};

package/eslint-integration/eslint-plugin-custom/c029-catch-block-logging.js

@@ -0,0 +1,80 @@
+/**
+ * Custom ESLint rule for: C029 – Every `catch` block must log the error cause
+ * Rule ID: custom/c029
+ * Goal: Catching errors without logging/rethrowing can hide bugs
+ * 
+ * NOTE: This ESLint rule provides basic catch block validation.
+ * For enhanced analysis with context validation and multi-level severity,
+ * use SunLint C029 which offers superior detection capabilities.
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Every `catch` block must log the error cause (C029)",
+      recommended: true,
+      url: "https://coding-standards.sun.com/rules/c029"
+    },
+    schema: [],
+    messages: {
+      silentCatch: "Catch block must log error or rethrow - silent error handling hides bugs (C029)",
+      emptyCatch: "Empty catch block - error is silently ignored (C029)"
+    }
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        const body = node.body && node.body.body;
+        
+        // Check for empty catch blocks
+        if (!Array.isArray(body) || body.length === 0) {
+          context.report({
+            node,
+            messageId: "emptyCatch"
+          });
+          return;
+        }
+
+        const hasLogOrThrow = body.some(stmt => {
+          // Check for throw statements
+          if (stmt.type === "ThrowStatement") {
+            return true;
+          }
+
+          // Check for console.log, console.error, console.warn
+          if (stmt.type === "ExpressionStatement" &&
+              stmt.expression.type === "CallExpression" &&
+              stmt.expression.callee &&
+              stmt.expression.callee.type === "MemberExpression" &&
+              stmt.expression.callee.object.name === "console" &&
+              (stmt.expression.callee.property.name === "log" ||
+               stmt.expression.callee.property.name === "error" ||
+               stmt.expression.callee.property.name === "warn")) {
+            return true;
+          }
+
+          // Check for custom logger calls (logger.error, log.error, etc.)
+          if (stmt.type === "ExpressionStatement" &&
+              stmt.expression.type === "CallExpression" &&
+              stmt.expression.callee &&
+              stmt.expression.callee.type === "MemberExpression" &&
+              (stmt.expression.callee.property.name === "error" ||
+               stmt.expression.callee.property.name === "warn" ||
+               stmt.expression.callee.property.name === "log")) {
+            return true;
+          }
+
+          return false;
+        });
+
+        if (!hasLogOrThrow) {
+          context.report({
+            node,
+            messageId: "silentCatch"
+          });
+        }
+      }
+    };
+  }
+};