@zxyycom/vibe-check 0.0.2 → 0.0.3

package/src/package-checks/file-metrics/scc/batch-planner.ts

@@ -0,0 +1,56 @@
+const TERMINAL_NUL_CODE_UNITS = 1;
+
+/** SCC adapter 的私有 Windows argv 传输上限；不属于 scanner options。 */
+export const SCC_BATCH_COMMAND_LINE_CEILING = 28_000;
+
+export type SccBatchPlan =
+  | { readonly batches: readonly (readonly string[])[]; readonly ok: true }
+  | { readonly error: string; readonly ok: false };
+
+/**
+ * 返回 Windows command-line serialization 的保守 UTF-16 code-unit 上界。
+ *
+ * 每个 argument 都按最多双倍转义并保留一对引号，arguments 之间保留一个分隔符，
+ * 最后保留 CreateProcessW 所需的终止 NUL。
+ */
+export function estimateSccCommandLineCodeUnits(argumentsToEstimate: readonly string[]): number {
+  return argumentsToEstimate.reduce(
+    (total, argument, index) => total + (index === 0 ? 0 : 1) + 2 * argument.length + 2,
+    TERMINAL_NUL_CODE_UNITS
+  );
+}
+
+/** 将已批准的 exact paths 按固定 SCC protocol 稳定地切为可传输 batches。 */
+export function planSccBatches(
+  executable: string,
+  fixedArguments: readonly string[],
+  includePaths: readonly string[],
+  ceiling = SCC_BATCH_COMMAND_LINE_CEILING
+): SccBatchPlan {
+  const batches: string[][] = [];
+  let currentBatch: string[] = [];
+
+  for (const includePath of includePaths) {
+    const singlePathArguments = [executable, ...fixedArguments, includePath];
+    if (estimateSccCommandLineCodeUnits(singlePathArguments) > ceiling) {
+      return {
+        ok: false,
+        error: `scc exact path cannot fit command-line ceiling ${ceiling}: ${JSON.stringify(includePath)}`
+      };
+    }
+
+    const candidateBatch = [...currentBatch, includePath];
+    if (
+      currentBatch.length > 0 &&
+      estimateSccCommandLineCodeUnits([executable, ...fixedArguments, ...candidateBatch]) > ceiling
+    ) {
+      batches.push(currentBatch);
+      currentBatch = [includePath];
+      continue;
+    }
+    currentBatch = candidateBatch;
+  }
+
+  if (currentBatch.length > 0) batches.push(currentBatch);
+  return { ok: true, batches };
+}

package/src/package-checks/file-metrics/scc/logical-scan-resources.ts

@@ -0,0 +1,59 @@
+import { DEFAULT_PROCESS_MAX_BUFFER_BYTES } from "../../host-environment/process.ts";
+
+export const SCC_LOGICAL_SCAN_TIMEOUT_MS = 300_000;
+const NANOSECONDS_PER_MILLISECOND = 1_000_000n;
+
+export interface SccLogicalScanResources {
+  readonly deadlineNanoseconds: bigint;
+  stderrRemainingBytes: number;
+  stdoutRemainingBytes: number;
+}
+
+/** 为一次 logical SCC scan 建立共享 deadline 与 stdout/stderr 预算。 */
+export function beginSccLogicalScanResources(
+  startedNanoseconds: bigint,
+  timeoutMilliseconds = SCC_LOGICAL_SCAN_TIMEOUT_MS,
+  outputBudgetBytes = DEFAULT_PROCESS_MAX_BUFFER_BYTES
+): SccLogicalScanResources {
+  return {
+    deadlineNanoseconds:
+      startedNanoseconds + BigInt(timeoutMilliseconds) * NANOSECONDS_PER_MILLISECOND,
+    stderrRemainingBytes: outputBudgetBytes,
+    stdoutRemainingBytes: outputBudgetBytes
+  };
+}
+
+/** 计算下一个 batch 可使用的完整毫秒数；deadline 到期时不再启动 process。 */
+export function remainingSccBatchTimeoutMs(
+  resources: SccLogicalScanResources,
+  nowNanoseconds: bigint
+): number | null {
+  const remainingNanoseconds = resources.deadlineNanoseconds - nowNanoseconds;
+  const remainingMilliseconds = Number(remainingNanoseconds / NANOSECONDS_PER_MILLISECOND);
+  return remainingMilliseconds > 0 ? remainingMilliseconds : null;
+}
+
+/** 以两个 stream 中较小的余量限制本次 process 的 maxBuffer。 */
+export function remainingSccBatchMaxBuffer(resources: SccLogicalScanResources): number | null {
+  const remainingBytes = Math.min(resources.stdoutRemainingBytes, resources.stderrRemainingBytes);
+  return remainingBytes > 0 ? remainingBytes : null;
+}
+
+/** 记录一次 process 的 UTF-8 output；任一 stream 超出完整 logical-scan 预算即失败。 */
+export function consumeSccProcessOutput(
+  resources: SccLogicalScanResources,
+  stdout: string,
+  stderr: string
+): boolean {
+  const stdoutBytes = Buffer.byteLength(stdout, "utf8");
+  const stderrBytes = Buffer.byteLength(stderr, "utf8");
+  if (
+    stdoutBytes > resources.stdoutRemainingBytes ||
+    stderrBytes > resources.stderrRemainingBytes
+  ) {
+    return false;
+  }
+  resources.stdoutRemainingBytes -= stdoutBytes;
+  resources.stderrRemainingBytes -= stderrBytes;
+  return true;
+}

package/src/package-checks/file-metrics/scc/scanner.ts

@@ -5,12 +5,23 @@
  */
 
 import { errorMessage } from "../../host-environment/error-message.ts";
-import { runProcessSync } from "../../host-environment/process.ts";
+import { runProcessSync, type ProcessResult } from "../../host-environment/process.ts";
+import { acceptExactInputMeasurements } from "../../project-files/exact-input-measurement.ts";
+import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
+import type { FileMetric } from "../measurement-model.ts";
 import type { ResolvedFileMetricsScannerOptions } from "../options.ts";
+import { planSccBatches } from "./batch-planner.ts";
+import {
+  beginSccLogicalScanResources,
+  consumeSccProcessOutput,
+  remainingSccBatchMaxBuffer,
+  remainingSccBatchTimeoutMs,
+  type SccLogicalScanResources
+} from "./logical-scan-resources.ts";
 import { parseSccCSV, type SccScanResult } from "./parser.ts";
 
 const SCC_BY_FILE_ARGUMENTS = Object.freeze(["--no-config", "--by-file", "--format", "csv"]);
-const SCC_SCAN_TIMEOUT_MS = 300_000;
+type SccMeasurement = ExactInputMeasurement<FileMetric>;
 
 interface ScanWithSccOptions {
   readonly cwd: string;
@@ -22,38 +33,19 @@ export function scanWithScc({ cwd, includePaths, scanner }: ScanWithSccOptions):
   try {
     if (includePaths.length === 0) return { ok: true, measurements: [] };
 
-    const scanArguments = buildSccArgs(includePaths);
+    const batchPlan = planSccBatches(scanner.executable, SCC_BY_FILE_ARGUMENTS, includePaths);
+    if (!batchPlan.ok) return { ok: false, error: batchPlan.error, reason: "execution" };
 
-    const commandResult = runProcessSync({
-      args: scanArguments,
-      command: scanner.executable,
-      cwd,
-      timeout: SCC_SCAN_TIMEOUT_MS
-    });
+    const logicalScanResources = beginSccLogicalScanResources(process.hrtime.bigint());
+    const measurements: SccMeasurement[] = [];
 
-    if (commandResult.error) {
-      return {
-        ok: false,
-        error: `scc process error: ${commandResult.error.message}`,
-        reason: "execution"
-      };
-    }
-
-    if (commandResult.status !== 0) {
-      const stderr = (commandResult.stderr || "").trim();
-      const stdout = (commandResult.stdout || "").trim();
-      const termination =
-        commandResult.status === null
-          ? `signal ${commandResult.signal ?? "unknown"}`
-          : `exit ${commandResult.status}`;
-      return {
-        ok: false,
-        error: `scc ${termination}: ${stderr || stdout || "no output"}`,
-        reason: "execution"
-      };
+    for (const batch of batchPlan.batches) {
+      const batchResult = scanSccBatch({ batch, cwd, logicalScanResources, scanner });
+      if (!batchResult.ok) return batchResult;
+      measurements.push(...batchResult.measurements);
     }
 
-    return parseSccCSV(commandResult.stdout || "", cwd);
+    return mergeSccBatchMeasurements(measurements);
   } catch (error: unknown) {
     return {
       ok: false,
@@ -63,6 +55,116 @@ export function scanWithScc({ cwd, includePaths, scanner }: ScanWithSccOptions):
   }
 }
 
-function buildSccArgs(includePaths: readonly string[]): string[] {
-  return [...SCC_BY_FILE_ARGUMENTS, ...includePaths];
+function scanSccBatch({
+  batch,
+  cwd,
+  logicalScanResources,
+  scanner
+}: {
+  readonly batch: readonly string[];
+  readonly cwd: string;
+  readonly logicalScanResources: SccLogicalScanResources;
+  readonly scanner: ResolvedFileMetricsScannerOptions;
+}): SccScanResult {
+  const remainingTimeoutMs = remainingSccBatchTimeoutMs(
+    logicalScanResources,
+    process.hrtime.bigint()
+  );
+  if (remainingTimeoutMs === null) return expiredSccDeadline();
+  const remainingMaxBufferBytes = remainingSccBatchMaxBuffer(logicalScanResources);
+  if (remainingMaxBufferBytes === null) return exhaustedSccOutputBudget();
+
+  const commandResult = runProcessSync({
+    args: [...SCC_BY_FILE_ARGUMENTS, ...batch],
+    command: scanner.executable,
+    cwd,
+    maxBuffer: remainingMaxBufferBytes,
+    timeout: remainingTimeoutMs
+  });
+  const processFailure = sccBatchProcessFailure(commandResult, logicalScanResources);
+  if (processFailure !== null) return processFailure;
+  return parseAcceptedSccBatch(commandResult.stdout, cwd, batch);
+}
+
+function expiredSccDeadline(): SccScanResult {
+  return {
+    ok: false,
+    error: "scc logical scan exceeded its shared timeout before the next batch",
+    reason: "execution"
+  };
+}
+
+function exhaustedSccOutputBudget(): SccScanResult {
+  return {
+    ok: false,
+    error: "scc logical scan exhausted its cumulative output budget before the next batch",
+    reason: "execution"
+  };
+}
+
+function sccBatchProcessFailure(
+  commandResult: ProcessResult,
+  logicalScanResources: SccLogicalScanResources
+): SccScanResult | null {
+  if (!consumeSccProcessOutput(logicalScanResources, commandResult.stdout, commandResult.stderr)) {
+    return {
+      ok: false,
+      error: "scc logical scan exceeded its cumulative stdout or stderr output budget",
+      reason: "execution"
+    };
+  }
+  if (commandResult.error) {
+    return {
+      ok: false,
+      error: `scc process error: ${commandResult.error.message}`,
+      reason: "execution"
+    };
+  }
+  if (commandResult.status === 0) return null;
+
+  const output = commandResult.stderr.trim() || commandResult.stdout.trim() || "no output";
+  const termination =
+    commandResult.status === null
+      ? `signal ${commandResult.signal ?? "unknown"}`
+      : `exit ${commandResult.status}`;
+  return { ok: false, error: `scc ${termination}: ${output}`, reason: "execution" };
+}
+
+function parseAcceptedSccBatch(
+  stdout: string,
+  cwd: string,
+  batch: readonly string[]
+): SccScanResult {
+  const parsed = parseSccCSV(stdout, cwd);
+  if (!parsed.ok) return parsed;
+  const acceptedMeasurements = acceptExactInputMeasurements(parsed.measurements, batch);
+  return acceptedMeasurements.ok
+    ? parsed
+    : { ok: false, error: acceptedMeasurements.error, reason: "invalid-result" };
+}
+
+function mergeSccBatchMeasurements(measurements: readonly SccMeasurement[]): SccScanResult {
+  const measuredPaths = new Set<string>();
+  for (const measurement of measurements) {
+    if (measuredPaths.has(measurement.payload.path)) {
+      return {
+        ok: false,
+        error: `scc returned duplicate measurement path ${JSON.stringify(measurement.payload.path)}`,
+        reason: "invalid-result"
+      };
+    }
+    measuredPaths.add(measurement.payload.path);
+  }
+  return {
+    ok: true,
+    measurements: [...measurements].sort((left, right) =>
+      compareText(left.payload.path, right.payload.path)
+    )
+  };
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
 }

package/src/package-checks/function-metrics/analysis.ts

@@ -174,9 +174,14 @@ function compareComplexityContributors(
 ): number {
   const commonLength = Math.min(left.length, right.length);
   for (let index = 0; index < commonLength; index += 1) {
-    const lineDifference = left[index].line - right[index].line;
+    const leftContributor = left[index];
+    const rightContributor = right[index];
+    if (leftContributor === undefined || rightContributor === undefined) {
+      throw new Error(`Complexity contributor index is out of range: ${index}`);
+    }
+    const lineDifference = leftContributor.line - rightContributor.line;
     if (lineDifference !== 0) return lineDifference;
-    const tokenDifference = compareText(left[index].token, right[index].token);
+    const tokenDifference = compareText(leftContributor.token, rightContributor.token);
     if (tokenDifference !== 0) return tokenDifference;
   }
   return left.length - right.length;

package/src/package-checks/function-metrics/analyzer/analysis-model.ts

@@ -270,7 +270,7 @@ export class FunctionInfo extends Nesting {
   public get parameters(): string[] {
     return this.fullParameters.flatMap((parameter) => {
       const match = /([\p{L}\p{N}_]+)(\s=.*)?(\s:.*)?$/u.exec(parameter);
-      return match?.[1] ? [match[1]] : [];
+      return match?.[1] !== undefined ? [match[1]] : [];
     });
   }
 

package/src/package-checks/function-metrics/analyzer/extension-output.ts

@@ -13,9 +13,9 @@ import { AttributeError, FileInformation, FunctionInfo } from "./analysis-model.
 import { isPythonWhitespace } from "./shared/code-reader.ts";
 
 export interface OutputSchemeItem {
-  caption?: string;
+  caption?: string | undefined;
   value: string;
-  avg_caption?: string;
+  avg_caption?: string | undefined;
 }
 
 /**
@@ -95,7 +95,11 @@ export class OutputScheme {
   }
 
   public captions(): string {
-    return this.items.flatMap((item) => (item.caption ? [item.caption] : [])).join("");
+    return this.items
+      .flatMap((item) =>
+        item.caption !== undefined && item.caption.length > 0 ? [item.caption] : []
+      )
+      .join("");
   }
 
   public static _head(captions: string): string {
@@ -114,7 +118,7 @@ export class OutputScheme {
   public function_info(functionInfo: FunctionInfo): string {
     let rendered = "";
     for (const item of this.items) {
-      if (!item.caption) continue;
+      if (item.caption === undefined || item.caption.length === 0) continue;
       rendered += pythonRightJustify(
         pythonString(readFunctionInfoAttribute(functionInfo, item.value)),
         Array.from(item.caption).length
@@ -128,7 +132,11 @@ export class OutputScheme {
   }
 
   public average_captions(): string {
-    return this.items.flatMap((item) => (item.avg_caption ? [item.avg_caption] : [])).join("");
+    return this.items
+      .flatMap((item) =>
+        item.avg_caption !== undefined && item.avg_caption.length > 0 ? [item.avg_caption] : []
+      )
+      .join("");
   }
 
   public averageCaptions(): string {
@@ -138,7 +146,7 @@ export class OutputScheme {
   public average_formatter(): string {
     return this.items
       .flatMap((item) => {
-        if (!item.avg_caption) return [];
+        if (item.avg_caption === undefined || item.avg_caption.length === 0) return [];
         return [`{module.average_${item.value}:${Array.from(item.avg_caption).length}.1f}`];
       })
       .join("");

package/src/package-checks/function-metrics/analyzer/extensions/lizardcomplextags.ts

@@ -16,9 +16,7 @@ export class LizardExtension implements LizardExtensionProtocol {
     const conditions = reader.conditions;
     for (const token of tokens) {
       yield token;
-      if (context.current_function.complex_tags === undefined) {
-        context.current_function.complex_tags = [];
-      }
+      context.current_function.complex_tags ??= [];
       if (conditions.has(token)) {
         context.current_function.complex_tags.push([token, context.current_line]);
       }

package/src/package-checks/function-metrics/analyzer/extensions/protocol.ts

@@ -75,9 +75,9 @@ export interface LizardExtension {
 
 /** Python resolves extension class attributes and static methods through instances. */
 export interface LizardExtensionClassMetadata {
-  readonly ordering_index?: number;
-  readonly FUNCTION_INFO?: FunctionInfoDefinitions;
-  readonly silent_all_others?: boolean;
+  readonly ordering_index?: number | undefined;
+  readonly FUNCTION_INFO?: FunctionInfoDefinitions | undefined;
+  readonly silent_all_others?: boolean | undefined;
 }
 
 /** A directly registered class is an opaque descriptor, not a constructor to invoke at load time. */

package/src/package-checks/function-metrics/analyzer/pipeline.ts

@@ -67,10 +67,12 @@ export function* commentCounter(tokens: TokenStream, reader: AnalyzerReader): Ge
       reader.context.forgiveGlobal = true;
     } else if (strippedComment.startsWith("#lizard forgives(")) {
       const metricMatch = /#lizard forgives?\(([^)]*)\)/u.exec(strippedComment);
-      if (metricMatch?.[1]) {
+      if (metricMatch?.[1] !== undefined) {
         for (const metric of metricMatch[1].split(",")) {
           const trimmedMetric = stripPythonWhitespace(metric);
-          if (trimmedMetric) reader.context.currentFunction.forgivenMetrics.add(trimmedMetric);
+          if (trimmedMetric.length > 0) {
+            reader.context.currentFunction.forgivenMetrics.add(trimmedMetric);
+          }
         }
       }
     } else if (strippedComment.startsWith("#lizard forgive")) {

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

@@ -150,14 +150,14 @@ function* generatePygmentsCompatibleErlangTokenValues(sourceCode: string): Gener
     }
 
     const baseInteger = matchAt(ERLANG_BASE_INTEGER, sourceCode, index);
-    if (baseInteger) {
+    if (baseInteger !== undefined) {
       yield baseInteger;
       index += baseInteger.length;
       continue;
     }
 
     const integer = matchAt(ERLANG_INTEGER, sourceCode, index);
-    if (integer) {
+    if (integer !== undefined) {
       yield integer;
       index += integer.length;
       continue;
@@ -172,7 +172,7 @@ function* generatePygmentsCompatibleErlangTokenValues(sourceCode: string): Gener
     }
 
     const variable = matchAt(ERLANG_VARIABLE, sourceCode, index);
-    if (variable) {
+    if (variable !== undefined) {
       yield variable;
       index += variable.length;
       continue;
@@ -370,15 +370,15 @@ function consumeErlangDirective(
 
 function consumeErlangMacro(sourceCode: string, index: number): number {
   const variable = matchAt(ERLANG_VARIABLE, sourceCode, index);
-  if (variable) return index + variable.length;
+  if (variable !== undefined) return index + variable.length;
   return consumeErlangAtom(sourceCode, index);
 }
 
 function consumeErlangAtom(sourceCode: string, index: number): number {
   const quotedAtom = matchAt(ERLANG_QUOTED_ATOM, sourceCode, index);
-  if (quotedAtom) return index + quotedAtom.length;
+  if (quotedAtom !== undefined) return index + quotedAtom.length;
   const identifier = matchAt(ERLANG_ATOM_IDENTIFIER, sourceCode, index);
-  return identifier ? index + identifier.length : index;
+  return identifier !== undefined ? index + identifier.length : index;
 }
 
 function isPygmentsLineStart(sourceCode: string, index: number): boolean {

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

@@ -77,7 +77,7 @@ export class FortranReader extends CodeReader {
       newLine = token === "\n";
 
       const macro = /^#\s*(\w+)/u.exec(token)?.[1]?.toLowerCase();
-      if (macro) {
+      if (macro !== undefined) {
         if (["if", "ifdef", "ifndef", "elif"].includes(macro)) this.context.addCondition();
         if (macroDepth > 0) {
           if (["if", "ifdef", "ifndef"].includes(macro)) macroDepth += 1;

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

@@ -38,7 +38,9 @@ class ObjCStates extends CLikeStates {
     if (token === "typedef") {
       this.next(this._typedef, token);
     } else if (token === "(") {
-      this.next((currentToken) => this._state_dec(currentToken), token);
+      this.next((currentToken) => {
+        this._state_dec(currentToken);
+      }, token);
     }
   }
 
@@ -59,7 +61,9 @@ class ObjCStates extends CLikeStates {
       this.next(this._state_objc_dec);
       this.context.addToFunctionName(token);
     } else if (token === "{") {
-      this.next((currentToken) => this._state_entering_imp(currentToken), "{");
+      this.next((currentToken) => {
+        this._state_entering_imp(currentToken);
+      }, "{");
     } else {
       this.next(this.globalState);
     }
@@ -73,7 +77,9 @@ class ObjCStates extends CLikeStates {
     } else if (token === ",") {
       // Source ignores selector commas.
     } else if (token === "{") {
-      this.next((currentToken) => this._state_entering_imp(currentToken), "{");
+      this.next((currentToken) => {
+        this._state_entering_imp(currentToken);
+      }, "{");
     } else {
       this.next(this._state_objc_dec_begin);
       this.context.addToFunctionName(` ${token}`);

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

@@ -95,7 +95,7 @@ export class PHPLanguageStates extends CodeStateMachine {
   };
 
   private readonly _trait_declaration = (token: string): void => {
-    if (token && !isPythonWhitespace(token) && !["{", "("].includes(token)) {
+    if (token.length > 0 && !isPythonWhitespace(token) && !["{", "("].includes(token)) {
       this.trait_name = token;
       this.in_trait = true;
       this._state = this._state_global;
@@ -107,7 +107,7 @@ export class PHPLanguageStates extends CodeStateMachine {
 
   private readonly _class_declaration = (token: string): void => {
     if (
-      token &&
+      token.length > 0 &&
       !isPythonWhitespace(token) &&
       !["{", "(", "extends", "implements"].includes(token)
     ) {
@@ -123,10 +123,10 @@ export class PHPLanguageStates extends CodeStateMachine {
   private readonly _function_name = (token: string): void => {
     if (token && !isPythonWhitespace(token) && token !== "(") {
       const methodName = token;
-      if (this.in_class && this.class_name) {
+      if (this.in_class && this.class_name !== undefined && this.class_name.length > 0) {
         this.function_name = `${this.class_name}::${methodName}`;
         this.short_function_name = methodName;
-      } else if (this.in_trait && this.trait_name) {
+      } else if (this.in_trait && this.trait_name !== undefined && this.trait_name.length > 0) {
         this.function_name = `${this.trait_name}::${methodName}`;
         this.short_function_name = methodName;
       } else {
@@ -140,8 +140,10 @@ export class PHPLanguageStates extends CodeStateMachine {
       } else if (this.in_trait) {
         this.function_name = `${this.trait_name}::(anonymous)`;
       } else {
-        this.function_name = this.assignments.at(-1) || "(anonymous)";
-        if (this.assignments.at(-1)) this.assignments.pop();
+        const assignment = this.assignments.at(-1);
+        this.function_name =
+          assignment !== undefined && assignment.length > 0 ? assignment : "(anonymous)";
+        if (assignment !== undefined && assignment.length > 0) this.assignments.pop();
       }
       this.bracket_level = 1;
       this._state = this._function_args_continue;
@@ -153,7 +155,12 @@ export class PHPLanguageStates extends CodeStateMachine {
   private readonly _function_args = (token: string): void => {
     if (token !== "(") return;
     this.bracket_level = 1;
-    if (this.in_class && this.class_name && !this.is_function_declaration) {
+    if (
+      this.in_class &&
+      this.class_name !== undefined &&
+      this.class_name.length > 0 &&
+      !this.is_function_declaration
+    ) {
       this.context.pushNewFunction(this.short_function_name);
     } else {
       this.context.pushNewFunction(this.function_name);

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

@@ -54,7 +54,9 @@ export class PLSQLReader extends CodeReader {
           pendingTokens = [];
           continue;
         }
-        if (lastNonWhitespaceToken) yield lastNonWhitespaceToken;
+        if (lastNonWhitespaceToken !== undefined && lastNonWhitespaceToken.length > 0) {
+          yield lastNonWhitespaceToken;
+        }
         yield* pendingTokens;
         pendingTokens = [];
         lastNonWhitespaceToken = token;
@@ -63,7 +65,9 @@ export class PLSQLReader extends CodeReader {
       }
     }
 
-    if (lastNonWhitespaceToken) yield lastNonWhitespaceToken;
+    if (lastNonWhitespaceToken !== undefined && lastNonWhitespaceToken.length > 0) {
+      yield lastNonWhitespaceToken;
+    }
     yield* pendingTokens;
   }
 
@@ -246,13 +250,13 @@ class PLSQLStates extends CodeStateMachine {
     const lower = token.toLowerCase();
     if (lower === "procedure") {
       this.declaring_nested_function = true;
-      if (this.nested_br_level === undefined) this.nested_br_level = 0;
+      this.nested_br_level ??= 0;
       this.next(this._procedure_name);
       return;
     }
     if (lower === "function") {
       this.declaring_nested_function = true;
-      if (this.nested_br_level === undefined) this.nested_br_level = 0;
+      this.nested_br_level ??= 0;
       this.next(this._function_name);
       return;
     }

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

@@ -214,6 +214,7 @@ export class PythonReader extends CodeReader {
     tokenFactory?: TokenFactory
   ): Generator<string> {
     const quote = token.startsWith('"""') || token.startsWith("'''") ? token.slice(0, 3) : token[0];
+    if (quote === undefined) return;
     const body = token.slice(quote.length, -quote.length);
     let literal = "";
     let produced = false;
@@ -300,7 +301,7 @@ export class PythonReader extends CodeReader {
     const iterator = tokens[Symbol.iterator]();
     let next = iterator.next();
 
-    while (!next.done) {
+    while (next.done !== true) {
       const token = next.value;
       if (token === "\n") {
         atLineStart = true;
@@ -313,7 +314,7 @@ export class PythonReader extends CodeReader {
         const lookahead: string[] = [];
         let nextReal: string | undefined;
         next = iterator.next();
-        while (!next.done) {
+        while (next.done !== true) {
           lookahead.push(next.value);
           if (next.value !== "\n" && !isPythonWhitespace(next.value)) {
             nextReal = next.value;
@@ -329,7 +330,7 @@ export class PythonReader extends CodeReader {
         } else if (nextReal === "(" || nextReal === "[") {
           isKeyword = false;
           let depth = 1;
-          while (!next.done) {
+          while (next.done !== true) {
             const lookaheadToken = next.value;
             lookahead.push(lookaheadToken);
             if (["(", "[", "{"].includes(lookaheadToken)) depth += 1;

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

@@ -51,7 +51,7 @@ export class RReader extends CodeReader {
 }
 
 class RStates extends CodeStateMachine {
-  private recent_tokens: string[] = [];
+  private readonly recent_tokens: string[] = [];
   private brace_count = 0;
   private in_braced_function = false;
   private additional_function_names: string[] = [];
@@ -174,6 +174,7 @@ class RStates extends CodeStateMachine {
     let currentNameTokens: string[] = [];
     while (index >= 0) {
       const token = this.recent_tokens[index];
+      if (token === undefined) break;
       if (token === "<-" || token === "=") {
         if (currentNameTokens.length > 0) {
           functionNames.push(currentNameTokens.reverse().join(""));