@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/package-checks/function-metrics/analyzer/readers/fortran.ts

@@ -0,0 +1,294 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/fortran.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import {
+  CodeReader,
+  CodeStateMachine,
+  isPythonWhitespace,
+  type TokenFactory
+} from "../shared/code-reader.ts";
+
+/** Source mixin retained as a constructable class despite TypeScript's single inheritance. */
+export class FortranCommentsMixin {
+  public static get_comment_from_token(token: string): string | undefined {
+    return token.startsWith("!") ? token.slice(1) : undefined;
+  }
+
+  public static getCommentFromToken(token: string): string | undefined {
+    return this.get_comment_from_token(token);
+  }
+}
+
+export class FortranReader extends CodeReader {
+  public static override ext = ["f70", "f90", "f95", "f03", "f08", "f", "for", "ftn", "fpp"];
+  public static override languageNames = ["fortran"];
+  public static override controlFlowKeywords = new Set(["IF", "DO", "if", "do"]);
+  public static override logicalOperators = new Set([".AND.", ".OR.", ".and.", ".or."]);
+  public static override caseKeywords = new Set(["CASE", "case"]);
+  public static override ternaryOperators = new Set<string>();
+  public static readonly _blocks = [
+    "PROGRAM",
+    "MODULE",
+    "SUBMODULE",
+    "SUBROUTINE",
+    "FUNCTION",
+    "TYPE",
+    "INTERFACE",
+    "BLOCK",
+    "IF",
+    "DO",
+    "FORALL",
+    "WHERE",
+    "SELECT",
+    "ASSOCIATE"
+  ] as const;
+  public macro_disabled = false;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context, FortranReader);
+    this.parallelStates = [new FortranStates(context, this)];
+  }
+
+  public static override *generateTokens(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    const untilEnd = String.raw`(?:\\\n|[^\n])*`;
+    const endings = FortranReader._blocks.map((block) => String.raw`END\s*${block}`).join("|");
+    const sourceAddition = String.raw`(?i)//|#${untilEnd}|!${untilEnd}|^\*${untilEnd}|\.OR\.|\.AND\.|ELSE\s+IF|MODULE\s+PROCEDURE|${endings}${addition}`;
+    yield* CodeReader.generateTokens(sourceCode, sourceAddition, tokenFactory);
+  }
+
+  public *preprocess(tokens: TokenStream): Generator<string> {
+    let macroDepth = 0;
+    let newLine = true;
+    for (let token of tokens) {
+      if (newLine && (token[0]?.toUpperCase() === "C" || token[0] === "*")) {
+        token = `!${token.slice(1)}`;
+      }
+      newLine = token === "\n";
+
+      const macro = /^#\s*(\w+)/u.exec(token)?.[1]?.toLowerCase();
+      if (macro !== undefined) {
+        if (["if", "ifdef", "ifndef", "elif"].includes(macro)) this.context.addCondition();
+        if (macroDepth > 0) {
+          if (["if", "ifdef", "ifndef"].includes(macro)) macroDepth += 1;
+          else if (macro === "endif") macroDepth -= 1;
+        } else if (["else", "elif"].includes(macro)) {
+          macroDepth += 1;
+        }
+        this.macro_disabled = macroDepth !== 0;
+      } else if (!isPythonWhitespace(token) || token === "\n") {
+        yield token;
+      }
+    }
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return FortranCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+/* Source state callbacks retain their method identity; CodeStateMachine supplies the owning receiver. */
+/* oxlint-disable typescript/unbound-method */
+class FortranStates extends CodeStateMachine {
+  private readonly reader: FortranReader;
+  private in_interface = false;
+  public static readonly _ends = new RegExp(`END\\s*(?:${FortranReader._blocks.join("|")})`, "iu");
+  public static readonly IGNORE_NEXT_TOKENS = new Set(["%", "::", "SAVE", "DATA"]);
+  public static readonly IGNORE_VAR_TOKENS = new Set([
+    "INTEGER",
+    "REAL",
+    "COMPLEX",
+    "LOGICAL",
+    "CHARACTER"
+  ]);
+  public static readonly RESET_STATE_TOKENS = new Set(["RECURSIVE", "ELEMENTAL"]);
+  public static readonly FUNCTION_NAME_TOKENS = new Set(["SUBROUTINE", "FUNCTION"]);
+  public static readonly NESTING_KEYWORDS = new Set([
+    "FORALL",
+    "WHERE",
+    "SELECT",
+    "INTERFACE",
+    "ASSOCIATE"
+  ]);
+  public static readonly PROCEDURE_TOKENS = new Set(["PROCEDURE", "MODULE PROCEDURE"]);
+
+  public constructor(context: FileInfoBuilder, reader: FortranReader) {
+    super(context);
+    this.reader = reader;
+    this.last_token = undefined;
+  }
+
+  public override consume(token: string): boolean {
+    if (this.reader.macro_disabled) return false;
+
+    // fortran.py defines its own `__call__`; unlike the shared base it keeps a
+    // completed callback installed. Retain that reader-local source behavior.
+    if (this.invokeCurrentState(token)) {
+      this.next(this.saved_state);
+      this.callback?.();
+    }
+    this.last_token = token;
+    return this.to_exit;
+  }
+
+  public override _state_global(token: string): void {
+    const upper = token.toUpperCase();
+    if (FortranStates.IGNORE_NEXT_TOKENS.has(upper)) this._state = this._ignore_next;
+    else if (FortranStates.IGNORE_VAR_TOKENS.has(upper)) {
+      this._state = this._ignore_var;
+    } else if (token === "(") {
+      this.next(this._ignore_expr, token);
+    } else if (FortranStates.RESET_STATE_TOKENS.has(upper)) {
+      this.reset_state();
+    } else if (FortranStates.FUNCTION_NAME_TOKENS.has(upper)) {
+      this._state = this._function_name;
+    } else if (upper === "PROGRAM") {
+      this._state = this._namespace;
+    } else if (upper === "MODULE") {
+      this._state = this._module_or_procedure;
+    } else if (upper === "SUBMODULE") {
+      this._state = this._module;
+      this._module(token);
+    } else if (upper === "TYPE") {
+      this._state = this._type;
+    } else if (upper === "IF") {
+      this._state = this._if;
+    } else if (upper === "BLOCK") {
+      this._state = this._ignore_if_paren;
+    } else if (upper === "DO") {
+      this._state = this._ignore_if_label;
+    } else if (FortranStates.NESTING_KEYWORDS.has(upper)) {
+      this.context.addBareNesting();
+      if (upper === "INTERFACE") this.in_interface = true;
+    } else if (upper === "ELSE") {
+      this.context.popNesting();
+      this.context.addBareNesting();
+    } else if (upper.replaceAll(" ", "") === "ELSEIF") {
+      this.context.popNesting();
+      if (upper === "ELSEIF") this.context.addCondition();
+      this._state = this._if;
+    } else if (upper === "END" || FortranStates._ends.test(token)) {
+      if (upper.replaceAll(" ", "").startsWith("ENDINTERFACE")) this.in_interface = false;
+      this.context.popNesting();
+    }
+  }
+
+  private readonly reset_state = (token?: string): void => {
+    this._state = this._state_global;
+    if (token !== undefined) this._state_global(token);
+  };
+
+  private readonly _ignore_next = (_token: string): void => {
+    this.reset_state();
+  };
+
+  private readonly _ignore_var = (token: string): void => {
+    if (FortranStates.FUNCTION_NAME_TOKENS.has(token.toUpperCase())) this.reset_state(token);
+    else this.reset_state();
+  };
+
+  private readonly _ignore_if_paren = (token: string): void => {
+    if (token === "(") this.next(this._ignore_expr, token);
+    else {
+      this.context.addBareNesting();
+      this.reset_state();
+    }
+  };
+
+  private readonly _ignore_if_label = (token: string): void => {
+    if (/^\d+$/u.test(token)) this.reset_state();
+    else {
+      this.context.addBareNesting();
+      this.reset_state(token);
+    }
+  };
+
+  private readonly _ignore_expr = (token: string): void => {
+    this.readInsideBracketsThen("()", token, () => {}, this._state_global);
+  };
+
+  private readonly _function_name = (token: string): void => {
+    this.context.restartNewFunction(token);
+    this.context.addToLongFunctionName("(");
+    this._state = this._function_has_param;
+  };
+
+  private readonly _function_has_param = (token: string): void => {
+    if (token === "(") this.next(this._function_params, token);
+    else this._function(token);
+  };
+
+  private readonly _function_params = (token: string): void => {
+    this.readInsideBracketsThen(
+      "()",
+      token,
+      (parameterToken) => {
+        if (!"()".includes(parameterToken)) this.context.parameter(parameterToken);
+      },
+      this._function
+    );
+  };
+
+  private readonly _function = (token: string): void => {
+    this.context.addToLongFunctionName(" )");
+    this.context.addBareNesting();
+    this.reset_state(token);
+  };
+
+  private readonly _module = (token: string): void => {
+    const upper = token.toUpperCase();
+    if (FortranStates.FUNCTION_NAME_TOKENS.has(upper)) this._state = this._function_name;
+    else if (FortranStates.PROCEDURE_TOKENS.has(upper)) this._state = this._procedure;
+    else this._namespace(token);
+  };
+
+  private readonly _procedure = (token: string): void => {
+    this.context.restartNewFunction(token);
+    this.context.addBareNesting();
+    this.reset_state();
+  };
+
+  private readonly _type = (token: string): void => {
+    if (token === "," || token === "::" || /^\p{L}/u.test(token)) this._namespace(token);
+    else this.reset_state(token);
+  };
+
+  private readonly _namespace = (token: string): void => {
+    this.context.addNamespace(token);
+    this.reset_state();
+  };
+
+  private readonly _if = (token: string): void => {
+    if (token === "(") this.next(this._if_cond, token);
+    else this.reset_state(token);
+  };
+
+  private readonly _if_cond = (token: string): void => {
+    this.readInsideBracketsThen("()", token, () => {}, this._if_then);
+  };
+
+  private readonly _if_then = (token: string): void => {
+    if (token.toUpperCase() === "THEN") {
+      this.context.addBareNesting();
+      this.reset_state();
+    } else {
+      this.reset_state(token);
+    }
+  };
+
+  private readonly _module_or_procedure = (token: string): void => {
+    if (token.toUpperCase() === "PROCEDURE") this._state = this._procedure;
+    else this._module(token);
+  };
+}
+/* oxlint-enable typescript/unbound-method */

package/src/package-checks/function-metrics/analyzer/readers/gdscript.ts

@@ -0,0 +1,42 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/gdscript.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript for the product-owned analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { PythonReader, PythonStates } from "./python.ts";
+
+export class GDScriptReader extends PythonReader {
+  public static override ext: readonly string[] = ["gd"];
+  public static override languageNames: readonly string[] = ["GDScript"];
+  public static override controlFlowKeywords = new Set([
+    "if",
+    "elif",
+    "for",
+    "while",
+    "catch",
+    "do"
+  ]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set(["case"]);
+  public static override ternaryOperators = new Set(["?"]);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context, GDScriptReader);
+    this.parallelStates = [new GDScriptStates(context, this)];
+  }
+}
+
+class GDScriptStates extends PythonStates {
+  public constructor(context: FileInfoBuilder, reader: PythonReader) {
+    super(context, reader);
+    this.next(this._state_global);
+  }
+
+  public override readonly _state_global = (token: string): void => {
+    if (token === "func") this.next(this._function);
+  };
+}

package/src/package-checks/function-metrics/analyzer/readers/go.ts

@@ -0,0 +1,53 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/go.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+import { GoLikeStates } from "../shared/golike.ts";
+
+export class GoReader extends CodeReader {
+  public static override ext = ["go"];
+  public static override languageNames = ["go"];
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new GoStates(context)];
+  }
+
+  public static override generateTokens(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return CodeReader.generateTokens(sourceCode, `${addition}|\`[^\`]*\``, tokenFactory);
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+
+  public override *__call__(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+    this.context = reader.context;
+    for (const token of tokens) {
+      if (token.startsWith("`") && token.endsWith("`")) {
+        for (const state of this.parallel_states) state.consume(token);
+        yield token;
+        continue;
+      }
+
+      for (const state of this.parallel_states) state.consume(token);
+      yield token;
+    }
+    for (const state of this.parallel_states) state.statemachine_before_return();
+    this.eof();
+  }
+}
+
+class GoStates extends GoLikeStates {}

package/src/package-checks/function-metrics/analyzer/readers/java-body-states.ts

@@ -0,0 +1,141 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/java_body_states.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Java method- and
+ * class-body nesting states.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { JavaStates } from "./java.ts";
+
+/**
+ * Binds source body-state subclasses after JavaStates exists, avoiding an ESM
+ * initialization cycle while retaining the source module's class boundaries.
+ */
+export function createJavaBodyStates(
+  JavaStatesBase: typeof JavaStates,
+  javaBraceCount: Readonly<Record<string, number>>
+): {
+  readonly JavaClassBodyStates: new (
+    className: string | undefined,
+    isRecord: boolean,
+    context: FileInfoBuilder
+  ) => JavaStates;
+  readonly JavaFunctionBodyStates: new (
+    context: FileInfoBuilder,
+    exitWithBraceDepth?: boolean
+  ) => JavaStates;
+} {
+  /** Direct translation of lizard_languages.java_body_states.JavaFunctionBodyStates. */
+  class JavaFunctionBodyStates extends JavaStatesBase {
+    private ignore_tokens = false;
+    private readonly _exit_with_brace_depth: boolean;
+    private _java_block_brace = 0;
+
+    public constructor(context: FileInfoBuilder, exitWithBraceDepth = true) {
+      super(context);
+      this.in_method_body = true;
+      this._exit_with_brace_depth = exitWithBraceDepth;
+    }
+
+    public override _state_global(token: string): void {
+      this.readInsideBracketsThen("{}", token, this.stateInsideBraces, this._state_dummy);
+    }
+
+    private readonly stateInsideBraces = (token: string): void => {
+      this.readInsideBracketsThen("()", token, this.stateFunctionBody, this._state_dummy);
+    };
+
+    private readonly stateFunctionBody = (token: string): void => {
+      if (this._consume_java_expression_tokens(token)) return;
+      const useAfterAnnotation = this._java_after_unqualified_annotation;
+      if (token !== "record") this._java_after_unqualified_annotation = false;
+      if (token === "@") {
+        this.next(this._state_decorator);
+        return;
+      }
+      if (this._try_start_a_class(token, useAfterAnnotation)) return;
+      if (this.ignore_tokens) {
+        this.ignore_tokens = false;
+        return;
+      }
+      if (token === "new") {
+        this.next(this._state_new);
+      } else if (this._exit_with_brace_depth) {
+        const braceDelta = javaBraceCount[token];
+        if (braceDelta !== undefined) {
+          this._java_block_brace += braceDelta;
+          if (this._java_block_brace === 0) this.returnFromState();
+        }
+      } else if (this.br_count === 0) {
+        this.returnFromState();
+      }
+    };
+
+    private readonly _state_dummy = (_token: string): void => {};
+  }
+
+  /** Direct translation of lizard_languages.java_body_states.JavaClassBodyStates. */
+  class JavaClassBodyStates extends JavaStatesBase {
+    private _after_static_keyword = false;
+    private _class_body_brace = 0;
+
+    public constructor(className: string | undefined, isRecord: boolean, context: FileInfoBuilder) {
+      super(context);
+      this.class_name = className;
+      this.is_record = isRecord;
+    }
+
+    public override _state_global(token: string): void {
+      if (this._after_static_keyword) {
+        this._after_static_keyword = false;
+        if (token === "{") {
+          this._class_body_brace += 1;
+          this.subState(
+            new JavaFunctionBodyStates(this.context, true),
+            () => {
+              this._class_body_brace -= 1;
+            },
+            token
+          );
+          return;
+        }
+        super._state_global("static");
+        super._state_global(token);
+        if (token === "}" && this._class_body_brace === 0) this.returnFromState();
+        return;
+      }
+
+      if (token === "static") {
+        this._after_static_keyword = true;
+        return;
+      }
+
+      if (token === "{" && ["{", "}", ";"].includes(this.lastToken ?? "")) {
+        this._class_body_brace += 1;
+        this.subState(
+          new JavaFunctionBodyStates(this.context, true),
+          () => {
+            this._class_body_brace -= 1;
+          },
+          token
+        );
+        return;
+      }
+
+      if (token === "new") {
+        this.next(this._state_new);
+        return;
+      }
+
+      super._state_global(token);
+      const braceDelta = javaBraceCount[token];
+      if (braceDelta !== undefined) this._class_body_brace += braceDelta;
+      if (token === "}" && this._class_body_brace === 0) this.returnFromState();
+    }
+  }
+
+  return { JavaClassBodyStates, JavaFunctionBodyStates };
+}