js-code-detector 0.0.44 → 0.0.48

package/bin/runDiffDetect.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/cjs/index').runDiffDetect();

package/dist/cjs/index.d.ts

@@ -1,3 +1,4 @@
+import { cloneGitRepoAndGetDiff } from "./util/shared/gitDiffTool";
 export declare const gitDiffFileName = "git_diff.txt";
 export declare function getGitRepositoryAndBranch(): Promise<{
     gitUrl: string;
@@ -5,12 +6,17 @@ export declare function getGitRepositoryAndBranch(): Promise<{
 }>;
 export declare function sameCodeDetect(dirOfCwd?: string): Promise<void>;
 export declare function gitDiffDetect(): Promise<{
-    mdContent: string;
-    dependenceJson: Record<string, any>;
-    upstreamDependenceJson: Record<string, any>;
+    dependenceJson: {
+        import2export: Record<string, string>;
+        export2export: Record<string, string>;
+        mapFilePathToExportAllSources: Record<string, string[]>;
+        indirectExportMembers: Record<string, string>;
+    };
     partialDependenceJson: Record<string, any>;
     reports: {
         dangerIdentifiers: string[];
+        topEffectedExportsAdded: string[];
+        topEffectedExportsRemoved: string[];
         blockReports: {
             diff_txt: string[];
             infos: {
@@ -26,13 +32,11 @@ export declare function gitDiffDetect(): Promise<{
         filePath: string;
     }[];
 } | undefined>;
-export declare function gitDiffDetectByUrl(inputUrl: string): Promise<{
-    mdContent: string;
-    dependenceJson: Record<string, any>;
-    upstreamDependenceJson: Record<string, any>;
-    partialDependenceJson: Record<string, any>;
+export declare function getUpstreamDependenceJson(inputUrl: string, token: string, jsonKeys?: (keyof Awaited<ReturnType<typeof cloneGitRepoAndGetDiff>>)[]): Promise<{
     reports: {
         dangerIdentifiers: string[];
+        topEffectedExportsAdded: string[];
+        topEffectedExportsRemoved: string[];
         blockReports: {
             diff_txt: string[];
             infos: {
@@ -47,7 +51,26 @@ export declare function gitDiffDetectByUrl(inputUrl: string): Promise<{
         undefinedIdentifiers: string[];
         filePath: string;
     }[];
-} | undefined>;
-export declare function getUpstreamDependenceJson(inputUrl: string, token: string): Promise<{
-    [k: string]: string[];
-} | undefined>;
+    dependenceJson: {
+        import2export: Record<string, string>;
+        export2export: Record<string, string>;
+        mapFilePathToExportAllSources: Record<string, string[]>;
+        indirectExportMembers: Record<string, string>;
+    };
+    effectedCode: Record<string, any>;
+    upstreamDependenceJson: {};
+    repoType: string;
+    message: string;
+} | {
+    effectedCode: Record<string, any>;
+    upstreamDependenceJson: {};
+    repoType: string;
+    message: any;
+    reports?: undefined;
+    dependenceJson?: undefined;
+}>;
+export { isRepoTypeSupported } from "./util/shared/getRepoSupportFlag";
+export declare function runDiffDetect(compareUrl?: string, token?: string): Promise<{
+    repoType: string;
+    effectedImportUsage: [string, string][];
+}>;

package/dist/cjs/index.js

@@ -32,8 +32,9 @@ __export(src_exports, {
   getGitRepositoryAndBranch: () => getGitRepositoryAndBranch,
   getUpstreamDependenceJson: () => getUpstreamDependenceJson,
   gitDiffDetect: () => gitDiffDetect,
-  gitDiffDetectByUrl: () => gitDiffDetectByUrl,
   gitDiffFileName: () => gitDiffFileName,
+  isRepoTypeSupported: () => import_getRepoSupportFlag.isRepoTypeSupported,
+  runDiffDetect: () => runDiffDetect,
   sameCodeDetect: () => sameCodeDetect
 });
 module.exports = __toCommonJS(src_exports);
@@ -45,6 +46,8 @@ var import_readDirFiles = require("./util/shared/readDirFiles");
 var import_Core = __toESM(require("./util/ast_util/Core"));
 var import_parseGitLabDiffUril = require("./util/parseGitLabDiffUril");
 var import_gitDiffTool = require("./util/shared/gitDiffTool");
+var import_DetectService = require("./services/DetectService");
+var import_getRepoSupportFlag = require("./util/shared/getRepoSupportFlag");
 var gitDiffFileName = "git_diff.txt";
 async function getGitRepositoryAndBranch() {
   const res = await import_utils.execa.execa("git remote get-url origin", { shell: true });
@@ -70,21 +73,33 @@ async function gitDiffDetect() {
   const today = (0, import_dayjs.default)().format("YYYYMDD_HHmmss");
   return (0, import_gitDiffTool.gitDiffTool)({ gitRepoUrl: gitUrl, targetBranch: branchName, baseBranch: "master", tempDirPath: today, generateFile: void 0 });
 }
-async function gitDiffDetectByUrl(inputUrl) {
-  const today = (0, import_dayjs.default)().format("YYYYMDD_HHmmss") + Math.random().toString(36).slice(-5);
+async function getUpstreamDependenceJson(inputUrl, token, jsonKeys) {
   const gitInfo = (0, import_parseGitLabDiffUril.parseGitLabCompareUrl)(inputUrl);
-  return (0, import_gitDiffTool.gitDiffTool)({ ...gitInfo, tempDirPath: today, generateFile: [] });
+  return (0, import_gitDiffTool.cloneGitRepoAndGetDiff)(gitInfo.gitRepoUrl, gitInfo.targetBranch, { token, jsonKeys });
 }
-async function getUpstreamDependenceJson(inputUrl, token) {
-  const gitInfo = (0, import_parseGitLabDiffUril.parseGitLabCompareUrl)(inputUrl);
-  return (0, import_gitDiffTool.cloneGitRepoAndGetDiff)(gitInfo.gitRepoUrl, gitInfo.targetBranch, { cloneType: token ? "token" : void 0, token });
+async function runDiffDetect(compareUrl, token) {
+  const option = {
+    compareUrl,
+    token,
+    gitRepoUrl: "",
+    branchName: ""
+  };
+  if (!compareUrl || !token) {
+    const { gitUrl, branchName } = await getGitRepositoryAndBranch();
+    option.gitRepoUrl = gitUrl;
+    option.branchName = branchName;
+  }
+  const service = new import_DetectService.DetectService(option);
+  await service.run();
+  return service.formatResult();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getGitRepositoryAndBranch,
   getUpstreamDependenceJson,
   gitDiffDetect,
-  gitDiffDetectByUrl,
   gitDiffFileName,
+  isRepoTypeSupported,
+  runDiffDetect,
   sameCodeDetect
 });

package/dist/cjs/services/DetectService.d.ts

@@ -0,0 +1,35 @@
+import { parseGitLabCompareUrl } from "../util/parseGitLabDiffUril";
+import { ProjectService } from "./ProjectService";
+export declare class DetectService {
+    directoryInfo: {
+        tmpWorkDir: string;
+        sourceBranchDir: string;
+        targetBranchDir: string;
+    };
+    gitInfo: {
+        token: string;
+        repoType: string;
+    } & ReturnType<typeof parseGitLabCompareUrl>;
+    projectService: ProjectService | null;
+    constructor(option: {
+        compareUrl?: string;
+        gitRepoUrl?: string;
+        token?: string;
+        branchName?: string;
+    });
+    init(option: {
+        compareUrl?: string;
+        gitRepoUrl?: string;
+        token?: string;
+        branchName?: string;
+    }): Promise<void>;
+    run(): Promise<void>;
+    clean(): Promise<void>;
+    mkdir(): Promise<void>;
+    clone(): Promise<void>;
+    projectHandle(): Promise<void>;
+    formatResult(): {
+        repoType: string;
+        effectedImportUsage: [string, string][];
+    };
+}

package/dist/cjs/services/DetectService.js

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/DetectService.ts
+var DetectService_exports = {};
+__export(DetectService_exports, {
+  DetectService: () => DetectService
+});
+module.exports = __toCommonJS(DetectService_exports);
+var import_path = require("path");
+var import_await_to_js = __toESM(require("await-to-js"));
+var import_utils = require("@umijs/utils");
+var import_parseGitLabDiffUril = require("../util/parseGitLabDiffUril");
+var import_createRandomStr = __toESM(require("../util/createRandomStr"));
+var import_constants = require("../util/constants");
+var import_gitUtil = require("../util/shared/gitUtil");
+var import_getRepoSupportFlag = require("../util/shared/getRepoSupportFlag");
+var import_UmiProjectService = __toESM(require("./projectServiceClass/UmiProjectService"));
+var import_perf_hooks = require("perf_hooks");
+var DetectService = class {
+  constructor(option) {
+    this.directoryInfo = {
+      tmpWorkDir: "",
+      sourceBranchDir: "",
+      targetBranchDir: ""
+    };
+    this.gitInfo = {
+      token: "",
+      gitRepoUrl: "",
+      baseBranch: "",
+      targetBranch: "",
+      projectPathPart: "",
+      repoType: ""
+    };
+    this.projectService = null;
+    this.init(option);
+  }
+  async init(option) {
+    const { compareUrl, token, gitRepoUrl, branchName } = option;
+    const tmpWorkDir = (0, import_createRandomStr.default)();
+    this.directoryInfo = {
+      tmpWorkDir,
+      sourceBranchDir: (0, import_path.join)(tmpWorkDir, import_constants.SOURCE),
+      targetBranchDir: (0, import_path.join)(tmpWorkDir, import_constants.TARGET)
+    };
+    if (compareUrl) {
+      this.gitInfo = {
+        ...this.gitInfo,
+        ...(0, import_parseGitLabDiffUril.parseGitLabCompareUrl)(compareUrl),
+        repoType: ""
+      };
+    }
+    if (gitRepoUrl) {
+      this.gitInfo = {
+        ...this.gitInfo,
+        baseBranch: "master",
+        targetBranch: branchName || "master",
+        gitRepoUrl,
+        token: token || "",
+        repoType: ""
+      };
+    }
+  }
+  async run() {
+    await this.clean();
+    try {
+      import_perf_hooks.performance.mark("mkdir");
+      await this.mkdir();
+      import_perf_hooks.performance.mark("clone");
+      {
+        const duration = import_perf_hooks.performance.measure("mkdir", "mkdir", "clone").duration;
+        import_utils.logger.info(`mkdir 耗时: ${duration}ms`);
+      }
+      await this.clone();
+      import_perf_hooks.performance.mark("projectHandle");
+      {
+        const duration = import_perf_hooks.performance.measure("clone", "clone", "projectHandle").duration;
+        import_utils.logger.info(`clone 耗时: ${duration}ms`);
+      }
+      await this.projectHandle();
+      {
+        const duration = import_perf_hooks.performance.measure("projectHandle", "projectHandle").duration;
+        import_utils.logger.info(`项目处理耗时: ${duration}ms`);
+      }
+    } catch (e) {
+      import_utils.logger.error("失败:" + e.message);
+    } finally {
+      this.clean();
+    }
+  }
+  async clean() {
+    const dirPath = this.directoryInfo.tmpWorkDir;
+    if (!dirPath)
+      return;
+    const [err] = await (0, import_await_to_js.default)(import_utils.execa.execa(`rm -rf ${dirPath}`, { shell: true }));
+    if (err) {
+      import_utils.logger.error("临时目录删除失败");
+    }
+  }
+  async mkdir() {
+    const dirPath = this.directoryInfo.tmpWorkDir;
+    await import_utils.execa.execa(`mkdir -p ${dirPath}`, { shell: true });
+  }
+  async clone() {
+    import_utils.logger.info("开始克隆仓库");
+    const { tmpWorkDir } = this.directoryInfo;
+    const { gitRepoUrl, token, baseBranch, targetBranch } = this.gitInfo;
+    const repoUrl = token ? (0, import_parseGitLabDiffUril.getGitRepoUrlByToken)(gitRepoUrl, token || "") : gitRepoUrl;
+    const branchesAndTargetDirPaths = [
+      {
+        branch: baseBranch,
+        targetDirPath: (0, import_path.join)(tmpWorkDir, import_constants.SOURCE)
+      },
+      {
+        branch: targetBranch,
+        targetDirPath: (0, import_path.join)(tmpWorkDir, import_constants.TARGET)
+      }
+    ];
+    await Promise.all(branchesAndTargetDirPaths.map(({ branch, targetDirPath: targetDirPath2 }) => {
+      return (0, import_gitUtil.cloneRepoWithBranchAndDefault)(repoUrl, branch, targetDirPath2);
+    }));
+    const targetDirPath = (0, import_path.join)(tmpWorkDir, import_constants.TARGET);
+    await (0, import_gitUtil.execGitDiff)(targetDirPath, baseBranch, targetBranch);
+    const repoType = await (0, import_getRepoSupportFlag.getRepoType)((0, import_path.join)(targetDirPath, "package.json"));
+    this.gitInfo.repoType = repoType;
+    import_utils.logger.info("克隆仓库成功");
+  }
+  async projectHandle() {
+    var _a;
+    const { repoType } = this.gitInfo;
+    if (!(0, import_getRepoSupportFlag.isRepoTypeSupported)(repoType)) {
+      return;
+    }
+    if (repoType === "umi") {
+      this.projectService = new import_UmiProjectService.default(this);
+    }
+    await ((_a = this.projectService) == null ? void 0 : _a.run());
+  }
+  formatResult() {
+    var _a;
+    const repoType = this.gitInfo.repoType;
+    const { effectedImportUsage } = ((_a = this.projectService) == null ? void 0 : _a.outputResult) || { effectedImportUsage: [] };
+    return {
+      repoType,
+      effectedImportUsage
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DetectService
+});

package/dist/cjs/services/ProjectService.d.ts

@@ -0,0 +1,16 @@
+import { DetectService } from "./DetectService";
+import { formatGitDiffContent } from "../util/format_git_diff_content";
+import { IMadgeInstance } from "../util/report_util/getMadgeInstance";
+export interface ProjectService {
+    detectService: DetectService;
+    gitDiffDetail: ReturnType<typeof formatGitDiffContent>;
+    helpInfo: {
+        projectFileList: string[];
+        madgeResult: IMadgeInstance | null;
+        parsedAlias: Record<string, any>;
+    };
+    outputResult: {
+        effectedImportUsage: [string, string][];
+    };
+    run(): void;
+}

package/dist/cjs/services/ProjectService.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/ProjectService.ts
+var ProjectService_exports = {};
+module.exports = __toCommonJS(ProjectService_exports);

package/dist/cjs/services/projectServiceClass/UmiProjectService.d.ts

@@ -0,0 +1,13 @@
+import { GitDiffDetail } from "../../util/format_git_diff_content";
+import { DetectService } from "../DetectService";
+import { ProjectService } from "../ProjectService";
+export default class UmiProjectService implements ProjectService {
+    detectService: DetectService;
+    gitDiffDetail: GitDiffDetail[];
+    helpInfo: ProjectService['helpInfo'];
+    outputResult: ProjectService['outputResult'];
+    constructor(detectService: DetectService);
+    run(): Promise<void>;
+    parseGitDiffContent(): Promise<void>;
+    collectEffectedFiles(): Promise<void>;
+}

package/dist/cjs/services/projectServiceClass/UmiProjectService.js

@@ -0,0 +1,96 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/projectServiceClass/UmiProjectService.ts
+var UmiProjectService_exports = {};
+__export(UmiProjectService_exports, {
+  default: () => UmiProjectService
+});
+module.exports = __toCommonJS(UmiProjectService_exports);
+var import_format_git_diff_content = require("../../util/format_git_diff_content");
+var import_umi4ProjectUtil = require("../../util/shared/umi4ProjectUtil");
+var import_fs = require("fs");
+var import_path = require("path");
+var import__ = require("../../index");
+var import_collectUpstreamFiles = __toESM(require("../../util/shared/collectUpstreamFiles"));
+var import_createDependenceMap = require("../../util/report_util/createDependenceMap");
+var import_filterEffectedExportMember = __toESM(require("../../util/report_util/filterEffectedExportMember"));
+var UmiProjectService = class {
+  constructor(detectService) {
+    this.detectService = detectService;
+    this.gitDiffDetail = [];
+    this.helpInfo = {
+      projectFileList: [],
+      madgeResult: null,
+      parsedAlias: {}
+    };
+    this.outputResult = {
+      effectedImportUsage: []
+    };
+    this.detectService = detectService;
+  }
+  async run() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    const { madgeResult, parsedAlias } = await (0, import_umi4ProjectUtil.umi4SetUp)({ targetDirPath, invokeType: "remote" });
+    this.helpInfo.projectFileList = Object.keys(madgeResult.tree);
+    this.helpInfo.madgeResult = madgeResult;
+    this.helpInfo.parsedAlias = parsedAlias;
+    await this.parseGitDiffContent();
+    await this.collectEffectedFiles();
+  }
+  async parseGitDiffContent() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import__.gitDiffFileName), "utf-8");
+    this.gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
+  }
+  async collectEffectedFiles() {
+    const { madgeResult, parsedAlias } = this.helpInfo;
+    const projectFileList = this.helpInfo.projectFileList;
+    const targetBranchDir = this.detectService.directoryInfo.targetBranchDir;
+    const absPathPrefix = (0, import_path.join)(targetBranchDir, "/");
+    const validModifiedFiles = this.gitDiffDetail.reduce((acc, item) => {
+      const { filePath } = item;
+      this.helpInfo.projectFileList.includes(filePath) && acc.push(filePath);
+      return acc;
+    }, []);
+    const possibleEffectedFiles = (0, import_collectUpstreamFiles.default)(madgeResult, validModifiedFiles);
+    const possibleEffectedFilesFullPath = possibleEffectedFiles.map((file) => (0, import_path.join)(absPathPrefix, file));
+    const { import2export, indirectExportMembers } = (0, import_createDependenceMap.createExportedNameToReferenceLocalSet)(possibleEffectedFilesFullPath, parsedAlias, absPathPrefix, projectFileList);
+    const gitDiffDetail = this.gitDiffDetail;
+    const validGitDiffDetail = gitDiffDetail.filter((item) => possibleEffectedFiles.includes(item.filePath));
+    const effectedExportNames = validGitDiffDetail.map((item) => {
+      const { filePath, newBranchLineScope, startLineOfNew } = item;
+      const exportedNames = (0, import_filterEffectedExportMember.default)((0, import_path.join)(absPathPrefix, filePath), absPathPrefix, Number(startLineOfNew), Number(startLineOfNew) + Number(newBranchLineScope));
+      return exportedNames.map((name) => [filePath, name].join("#"));
+    }).flat();
+    const effectedImportUsage = [...Object.entries(import2export), ...Object.entries(indirectExportMembers)].filter(([_, value]) => {
+      return effectedExportNames.includes(value);
+    });
+    this.outputResult.effectedImportUsage = effectedImportUsage;
+  }
+};

package/dist/cjs/util/ast_util/AstUtil.d.ts

@@ -52,6 +52,7 @@ export interface AstNode {
 }
 export default class AstUtil {
     static invalidNodeKey: string[];
+    static EXPORT_DECLARATION_TYPES: string[];
     static getNodePath(node: AstNode): string;
     static getShortNodeMsg(node: AstNode, hideParentProperty?: boolean): string;
     static getAncestorsFromBirth(occupationId: AstNode, sourceId: AstNode): AstNode[];
@@ -59,12 +60,12 @@ export default class AstUtil {
     private static getImpactedNode;
     static deepFirstTravel(node: AstNode, filePath: string, mapUuidToNode: Map<string, AstNode>, mapFileLineToNodeSet: Map<number, Set<AstNode>>, mapPathToNodeSet: Map<string, Set<AstNode>>, stopTravelCallback?: (node: AstNode) => boolean | void): AstNode | undefined;
     private static _deepFirstTravel;
+    private static findRelatedExportNameOfDeclarationIdentifier;
+    static findExportedMembersNameFromAncestors(node: AstNode | undefined | null): string[];
     private static updateImportedAndExportedMember;
     private static collectInjectAndProvide;
     private static handleDeclaration;
     private static collectHoldingIds;
-    private static isVarInit;
-    static isReturnArgument(node: AstNode): boolean;
     private static collectDependenceIds;
     private static isUseStateVarDec;
     static isUseMemoVarDec(node: AstNode): boolean;
@@ -79,7 +80,6 @@ export default class AstUtil {
     private static collectEffectIdOfUnaryUpdate;
     private static isBodyArray;
     private static findExportIdentifiers;
-    private static expressionTypeIsIdentifier;
     static collectExpressionIdentifiersShallow(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
     private static _collectExpressionIdentifiersShallow;
     static collectExpressionIdentifiers(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
@@ -97,8 +97,5 @@ export default class AstUtil {
     static isPropertyOfGlobal(node: AstNode): boolean;
     static isIntrinsicElement(node: AstNode): boolean | "" | undefined;
     static isStandardAttribute(node: AstNode): boolean;
-    static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet: Map<number, Set<AstNode>>, lineNumberStart: number, lineNumberEnd: number): AstNode[];
-    static getTopScopeNodesByLineNumber(mapFileLineToNodeSet: Map<number, Set<AstNode>>, lineNumber: number): AstNode[];
-    static isSubNodeOfVariableDeclarator(node: AstNode): boolean;
-    static createScopeContent(node: AstNode): string;
+    static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet: Map<number, Set<AstNode>>, lineNumberStart: number, lineNumberEnd: number, loose?: boolean): AstNode[];
 }