@zxyycom/vibe-check 0.0.1 → 0.0.2

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

@@ -0,0 +1,270 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/java.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Java's source-derived
+ * C-like state overrides, record handling and nested class lifecycle.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeNestingStackStates, CLikeReader, CLikeStates } from "../shared/clike.ts";
+import { createJavaBodyStates } from "./java-body-states.ts";
+
+const JAVA_CLASS_MODIFIERS = new Set([
+  "public",
+  "private",
+  "protected",
+  "static",
+  "final",
+  "strictfp",
+  "abstract",
+  "synchronized",
+  "native",
+  "default",
+  "transient",
+  "volatile",
+  "sealed",
+  "non-sealed"
+]);
+const JAVA_TYPE_KEYWORDS = new Set([
+  "void",
+  "boolean",
+  "byte",
+  "char",
+  "short",
+  "int",
+  "long",
+  "float",
+  "double",
+  "var"
+]);
+export const JAVA_BRACE_COUNT: Readonly<Record<string, number>> = { "{": 1, "}": -1 };
+const JAVA_STATEMENT_KEYWORDS = new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "catch",
+  "try",
+  "finally",
+  "synchronized",
+  "return",
+  "throw",
+  "assert",
+  "break",
+  "continue",
+  "instanceof"
+]);
+
+function javaRecordBeginsTypeDeclaration(
+  lastToken: string | undefined,
+  afterUnqualifiedAnnotation: boolean
+): boolean {
+  if (afterUnqualifiedAnnotation || lastToken === undefined) return true;
+  if (JAVA_TYPE_KEYWORDS.has(lastToken) || lastToken === "]" || lastToken === ">") return false;
+  if (/^(?:_|\$|\{)/u.test(lastToken)) return false;
+  if (/^\p{Ll}/u.test(lastToken) && JAVA_CLASS_MODIFIERS.has(lastToken)) return true;
+  if (/^\p{Lu}/u.test(lastToken)) return false;
+  return ["{", "}", ";", ")", "@"].includes(lastToken);
+}
+
+/** Java reader with source-specific declaration and nested-class states. */
+export class JavaReader extends CLikeReader {
+  public static override ext: readonly string[] = ["java"];
+  public static override languageNames: readonly string[] = ["java"];
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new JavaStates(context), new CLikeNestingStackStates(context)];
+  }
+}
+
+/** Direct translation of lizard_languages.java.JavaStates. */
+export class JavaStates extends CLikeStates {
+  protected class_name: string | undefined;
+  protected is_record = false;
+  protected in_record_constructor = false;
+  protected in_method_body = false;
+  protected handling_dot_class = false;
+  protected handling_method_ref = false;
+  protected _java_after_unqualified_annotation = false;
+  protected _new_generic_depth = 0;
+
+  protected _consume_java_expression_tokens(token: string): boolean {
+    if (token === "::") {
+      this.handling_method_ref = true;
+      return true;
+    }
+    if (this.handling_method_ref) {
+      this.handling_method_ref = false;
+      return true;
+    }
+    if (token === "." && !this.handling_dot_class) {
+      this.handling_dot_class = true;
+      return true;
+    }
+    if (this.handling_dot_class) {
+      this.handling_dot_class = false;
+      if (token === "class") return true;
+    }
+    return false;
+  }
+
+  protected override _state_old_c_params(token: string): void {
+    if (token === "{") this._state_dec_to_imp(token);
+  }
+
+  protected override _state_imp(token: string): void {
+    this.in_method_body = true;
+    this.subState(
+      new JavaFunctionBodyStates(this.context, true),
+      () => {
+        this.in_method_body = false;
+        this.next(this.globalState);
+      },
+      token
+    );
+  }
+
+  public override try_new_function(name: string): void {
+    if (this.is_record && name === this.class_name) {
+      this.in_record_constructor = true;
+      this.next(this._state_record_compact_constructor);
+      return;
+    }
+    super.try_new_function(name);
+    if (this.class_name !== undefined && this.context.currentFunction !== undefined) {
+      this.context.currentFunction.name = `${this.class_name}::${name}`;
+    }
+  }
+
+  protected _try_start_a_class(token: string, afterUnqualifiedAnnotation = false): boolean {
+    if (token === "class" || token === "enum") {
+      this._java_after_unqualified_annotation = false;
+      this.class_name = undefined;
+      this.is_record = false;
+      this.in_record_constructor = false;
+      this.next(this._state_class_declaration);
+      return true;
+    }
+    if (token === "record") {
+      if (this.in_method_body) return false;
+      if (!javaRecordBeginsTypeDeclaration(this.lastToken, afterUnqualifiedAnnotation)) {
+        this._java_after_unqualified_annotation = false;
+        return false;
+      }
+      this._java_after_unqualified_annotation = false;
+      this.class_name = undefined;
+      this.is_record = true;
+      this.in_record_constructor = false;
+      this.next(this._state_class_declaration);
+      return true;
+    }
+    return false;
+  }
+
+  public override _state_global(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 (JAVA_STATEMENT_KEYWORDS.has(token)) return;
+    if (!this.in_record_constructor) super._state_global(token);
+  }
+
+  protected readonly _state_decorator = (_token: string): void => {
+    this.next(this._state_post_decorator);
+  };
+
+  protected readonly _state_annotation_arguments = (token: string): void => {
+    this.readInsideBracketsThen("()", token, this.ignoreJavaToken, this.globalState);
+  };
+
+  protected readonly _state_post_decorator = (token: string): void => {
+    if (token === ".") {
+      this.next(this._state_decorator);
+    } else if (token === "(") {
+      this.next(this._state_annotation_arguments, token);
+    } else {
+      this._java_after_unqualified_annotation = true;
+      this.next(this.globalState);
+    }
+  };
+
+  private readonly _state_class_declaration = (token: string): void => {
+    if (token === "{") {
+      this.subState(
+        new JavaClassBodyStates(this.class_name, this.is_record, this.context),
+        () => this.next(this.globalState),
+        token
+      );
+    } else if (token === "(") {
+      this.next(this._state_record_parameters);
+    } else if (/^\p{L}/u.test(token) && this.class_name === undefined) {
+      this.class_name = token;
+    }
+  };
+
+  private readonly _state_record_parameters = (token: string): void => {
+    if (token === ")") this.next(this._state_class_declaration);
+  };
+
+  private readonly _state_record_compact_constructor = (token: string): void => {
+    if (token === "{") {
+      this.next(this._state_record_constructor_body);
+      return;
+    }
+    this.next(this.globalState, token);
+  };
+
+  private readonly _state_record_constructor_body = (token: string): void => {
+    if (token === "}") {
+      this.in_record_constructor = false;
+      this.next(this.globalState);
+    }
+  };
+
+  protected readonly _state_new = (_token: string): void => {
+    this._new_generic_depth = 0;
+    this.next(this._state_new_parameters);
+  };
+
+  protected readonly _state_new_parameters = (token: string): void => {
+    if (this._new_generic_depth > 0 || token.startsWith("<")) {
+      this._new_generic_depth += countCharacters(token, "<") - countCharacters(token, ">");
+      return;
+    }
+    if (token === "(") {
+      this.subState(new JavaFunctionBodyStates(this.context, false), undefined, token);
+      return;
+    }
+    if (token === "{") {
+      this.subState(
+        new JavaClassBodyStates("(anonymous)", false, this.context),
+        () => this.next(this.globalState),
+        token
+      );
+      return;
+    }
+    if (token === "." || /^\p{L}/u.test(token) || token.startsWith("_")) return;
+    this.next(this.globalState, token);
+  };
+
+  private readonly ignoreJavaToken = (_token: string): void => {};
+}
+
+const { JavaClassBodyStates, JavaFunctionBodyStates } = createJavaBodyStates(
+  JavaStates,
+  JAVA_BRACE_COUNT
+);
+
+function countCharacters(value: string, character: string): number {
+  return value.split(character).length - 1;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/javascript.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { TypeScriptReader } from "./typescript.ts";
+
+export class JavaScriptReader extends TypeScriptReader {
+  public static override ext = ["js", "cjs", "mjs"];
+  public static override languageNames = ["javascript", "js"];
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+  }
+}

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

@@ -0,0 +1,120 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/kotlin.py and lizard_languages/swift.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 { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+import { GoLikeStates } from "../shared/golike.ts";
+import { SwiftReplaceLabel } from "./swift.ts";
+
+export class KotlinReader extends CodeReader {
+  public static override ext = ["kt", "kts"];
+  public static override languageNames = ["kotlin"];
+  public static override controlFlowKeywords = new Set(["if", "for", "while", "catch"]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set<string>();
+  public static override ternaryOperators = new Set(["?:"]);
+
+  private readonly replaceLabel: SwiftReplaceLabel;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new KotlinStates(context)];
+    this.replaceLabel = new SwiftReplaceLabel(this.conditions);
+  }
+
+  public static override generateTokens(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return CodeReader.generateTokens(
+      sourceCode,
+      String.raw`|\`\w+\`|\w+\?|\w+\!\!|\?\?|\?:${addition}`,
+      tokenFactory
+    );
+  }
+
+  public *preprocess(tokens: TokenStream): Generator<string> {
+    yield* this.replaceLabel.preprocess(tokens);
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+/* oxlint-disable typescript/unbound-method -- CodeStateMachine invokes stored source methods with this state. */
+class KotlinStates extends GoLikeStates {
+  protected static override readonly FUNC_KEYWORD = "fun";
+
+  private readonly _in_when_cases: boolean;
+
+  public constructor(context: FileInfoBuilder, _in_when_cases = false) {
+    super(context);
+    this._in_when_cases = _in_when_cases;
+  }
+
+  public override _state_global(token: string): void {
+    if (token === "get" || token === "set") {
+      this.context.pushNewFunction(token);
+      this.next(this._expect_function_impl);
+    } else if (token === "->") {
+      if (this._in_when_cases) {
+        this.context.addCondition();
+      } else {
+        this.context.pushNewFunction("(anonymous)");
+        this.next(super._expect_function_impl);
+      }
+    } else if (token === "val" || token === "var" || token === ",") {
+      this.next(this._expect_declaration_name);
+    } else if (token === "interface") {
+      this.next(this._interface);
+    } else if (token === "when") {
+      this.next(this._when_cases);
+    } else {
+      super._state_global(token);
+    }
+  }
+
+  protected override _expect_function_impl(token: string): void {
+    if (token === "{" || token === "=") this.next(this._function_impl, token);
+  }
+
+  protected override _function_name(token: string): void {
+    if (token === "<") {
+      this.next(this._template, token);
+      return;
+    }
+    super._function_name(token);
+  }
+
+  private readonly _expect_declaration_name = (_token: string): void => {
+    this.next(this.globalState);
+  };
+
+  private readonly _interface = (token: string): void => {
+    this.readInsideBracketsThen("{}", token, (endToken) => {
+      if (endToken === "}") this.next(this.globalState);
+    });
+  };
+
+  private readonly _template = (token: string): void => {
+    this.readInsideBracketsThen("<>", token, () => undefined, this._function_name);
+  };
+
+  private readonly _when_cases = (token: string): void => {
+    if (token !== "{") return;
+    this.subState(new KotlinStates(this.context, true), () => {
+      this.context.addCondition(-1);
+      this.next(this.globalState);
+    });
+  };
+}
+/* oxlint-enable typescript/unbound-method */

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

@@ -0,0 +1,68 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/lua.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 { RubylikeReader, RubylikeStateMachine } from "../shared/rubylike.ts";
+import { ScriptLanguageMixIn } from "../shared/script-language.ts";
+
+export class LuaReader extends RubylikeReader {
+  public static override ext: readonly string[] = ["lua"];
+  public static override languageNames: readonly string[] = ["lua"];
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new LuaStateMachine(context)];
+  }
+
+  public static override generateTokens(sourceCode: string): Generator<string> {
+    return ScriptLanguageMixIn.generate_common_tokens(
+      sourceCode,
+      String.raw`|--\[\[.*?\]\]|\[=*\[.*?\]=*\]|--.*?$`
+    );
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return token.startsWith("--") ? token : undefined;
+  }
+}
+
+class LuaStateMachine extends RubylikeStateMachine {
+  protected static override readonly FUNC_KEYWORD = "function";
+  private probable_function_name: string | undefined;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.probable_function_name = undefined;
+  }
+
+  public override _state_global(token: string): void {
+    if (token === "=") {
+      this.next(this._assigning);
+      return;
+    }
+    this.probable_function_name = token;
+    super._state_global(token);
+  }
+
+  private readonly _assigning = (token: string): void => {
+    if (token === "function") {
+      this.next(this._anonymous_def);
+      return;
+    }
+    this.next(this.globalState, token);
+  };
+
+  private readonly _anonymous_def = (token: string): void => {
+    if (token !== "(") {
+      this.next(this._def, token);
+      return;
+    }
+    this.context.pushNewFunction(this.probable_function_name ?? "(anonymous)");
+    this.next(this._def_parameters);
+  };
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/objc.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Objective-C's CLikeStates
+ * declaration override, selector lifecycle and typedef suppression.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeNestingStackStates, CLikeReader, CLikeStates } from "../shared/clike.ts";
+
+/** Objective-C reader with source-compatible C-like and selector state fan-out. */
+export class ObjCReader extends CLikeReader {
+  public static override ext: readonly string[] = ["m", "mm"];
+  public static override languageNames: readonly string[] = ["objectivec", "objective-c", "objc"];
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new ObjCStates(context), new CLikeNestingStackStates(context)];
+  }
+
+  public fake_and_useless(): void {}
+
+  public useless_and_fake(): void {}
+}
+
+/** Direct translation of lizard_languages.objc.ObjCStates. */
+class ObjCStates extends CLikeStates {
+  private _objc_param_paren_depth = 0;
+
+  public override statemachine_clone(): ObjCStates {
+    return new ObjCStates(this.context);
+  }
+
+  public override _state_global(token: string): void {
+    super._state_global(token);
+    if (token === "typedef") {
+      this.next(this._typedef, token);
+    } else if (token === "(") {
+      this.next((currentToken) => this._state_dec(currentToken), token);
+    }
+  }
+
+  protected override _state_dec_to_imp(token: string): void {
+    if (token === "+" || token === "-") {
+      this.next(this.globalState);
+      return;
+    }
+    super._state_dec_to_imp(token);
+    if (this.state !== this._state_imp) {
+      this.next(this._state_objc_dec_begin);
+      this.context.restartNewFunction(token);
+    }
+  }
+
+  private readonly _state_objc_dec_begin = (token: string): void => {
+    if (token === ":") {
+      this.next(this._state_objc_dec);
+      this.context.addToFunctionName(token);
+    } else if (token === "{") {
+      this.next((currentToken) => this._state_entering_imp(currentToken), "{");
+    } else {
+      this.next(this.globalState);
+    }
+  };
+
+  private readonly _state_objc_dec = (token: string): void => {
+    if (token === "(") {
+      this._objc_param_paren_depth = 0;
+      this.next(this._state_objc_param_type);
+      this.context.addToLongFunctionName(token);
+    } else if (token === ",") {
+      // Source ignores selector commas.
+    } else if (token === "{") {
+      this.next((currentToken) => this._state_entering_imp(currentToken), "{");
+    } else {
+      this.next(this._state_objc_dec_begin);
+      this.context.addToFunctionName(` ${token}`);
+    }
+  };
+
+  private readonly _state_objc_param_type = (token: string): void => {
+    if (token === "(") {
+      this._objc_param_paren_depth += 1;
+    } else if (token === ")") {
+      if (this._objc_param_paren_depth > 0) {
+        this._objc_param_paren_depth -= 1;
+      } else {
+        this.next(this._state_objc_param);
+      }
+    }
+    this.context.addToLongFunctionName(` ${token}`);
+  };
+
+  private readonly _state_objc_param = (_token: string): void => {
+    this.next(this._state_objc_dec);
+  };
+
+  private readonly _typedef = (token: string): void => {
+    this.readUntilThen(";", token, this.finishTypedef);
+  };
+
+  private readonly finishTypedef = (_token: string, _savedTokens: readonly string[]): void => {
+    this.next(this.globalState);
+  };
+}