From 17737278ae1a53bd7a153bbb4ff5dc2afed4e8a7 Mon Sep 17 00:00:00 2001 From: Johannes Date: Fri, 11 Nov 2022 13:48:21 +0100 Subject: [PATCH] rename to typescript manger, (mostly) use language service rename feature --- build/lib/mangleTypeScript.js | 424 +++++++++++++++++++++++++++++ build/lib/mangleTypeScript.ts | 495 ++++++++++++++++++++++++++++++++++ 2 files changed, 919 insertions(+) create mode 100644 build/lib/mangleTypeScript.js create mode 100644 build/lib/mangleTypeScript.ts diff --git a/build/lib/mangleTypeScript.js b/build/lib/mangleTypeScript.js new file mode 100644 index 00000000000..b1dcc4a7494 --- /dev/null +++ b/build/lib/mangleTypeScript.js @@ -0,0 +1,424 @@ +"use strict"; +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +Object.defineProperty(exports, "__esModule", { value: true }); +const ts = require("typescript"); +const fancy_log_1 = require("fancy-log"); +const path_1 = require("path"); +const fs = require("fs"); +class ShortIdent { + static _keywords = new Set(['await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', + 'default', 'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', + 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return', 'static', 'super', 'switch', 'this', 'throw', + 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']); + static alphabet = []; + static { + for (let i = 97; i < 122; i++) { + this.alphabet.push(String.fromCharCode(i)); + } + for (let i = 65; i < 90; i++) { + this.alphabet.push(String.fromCharCode(i)); + } + } + _value = 0; + _isNameTaken; + constructor(isNameTaken) { + this._isNameTaken = name => { + return ShortIdent._keywords.has(name) || isNameTaken(name); + }; + } + next() { + const candidate = ShortIdent.convert(this._value); + this._value++; + if (this._isNameTaken(candidate)) { + // try again + return this.next(); + } + return candidate; + } + static convert(n) { + const base = this.alphabet.length; + let result = ''; + do { + const rest = n % 50; + result += this.alphabet[rest]; + n = (n / base) | 0; + } while (n > 0); + return result; + } +} +const projectPath = 1 + ? (0, path_1.join)(__dirname, '../../src/tsconfig.json') + : '/Users/jrieken/Code/_samples/3wm/mangePrivate/tsconfig.json'; +const existingOptions = {}; +const parsed = ts.readConfigFile(projectPath, ts.sys.readFile); +if (parsed.error) { + console.log(fancy_log_1.error); + throw parsed.error; +} +const cmdLine = ts.parseJsonConfigFileContent(parsed.config, ts.sys, (0, path_1.dirname)(projectPath), existingOptions); +if (cmdLine.errors.length > 0) { + console.log(fancy_log_1.error); + throw parsed.error; +} +const host = new class { + _scriptSnapshots = new Map(); + getCompilationSettings() { + return cmdLine.options; + } + getScriptFileNames() { + return cmdLine.fileNames; + } + getScriptVersion(_fileName) { + return '1'; + } + getProjectVersion() { + return '1'; + } + getScriptSnapshot(fileName) { + let result = this._scriptSnapshots.get(fileName); + if (result === undefined) { + const content = ts.sys.readFile(fileName); + if (content === undefined) { + return undefined; + } + result = ts.ScriptSnapshot.fromString(content); + this._scriptSnapshots.set(fileName, result); + } + return result; + } + getCurrentDirectory() { + return (0, path_1.dirname)(projectPath); + } + getDefaultLibFileName(options) { + return ts.getDefaultLibFilePath(options); + } + directoryExists = ts.sys.directoryExists; + getDirectories = ts.sys.getDirectories; + fileExists = ts.sys.fileExists; + readFile = ts.sys.readFile; + readDirectory = ts.sys.readDirectory; + // this is necessary to make source references work. + realpath = ts.sys.realpath; +}; +const allClassDataBySymbol = new Map(); +const service = ts.createLanguageService(host); +const program = service.getProgram(); +const checker = program.getTypeChecker(); +var FieldType; +(function (FieldType) { + FieldType[FieldType["Public"] = 0] = "Public"; + FieldType[FieldType["Protected"] = 1] = "Protected"; + FieldType[FieldType["Private"] = 2] = "Private"; +})(FieldType || (FieldType = {})); +class ClassData { + fileName; + node; + symbol; + fields = new Map(); + replacements; + parent; + children; + constructor(fileName, node, symbol) { + // analyse all fields (properties and methods). Find usages of all protected and + // private ones and keep track of all public ones (to prevent naming collisions) + this.fileName = fileName; + this.node = node; + this.symbol = symbol; + const candidates = []; + for (const member of node.members) { + if (ts.isMethodDeclaration(member)) { + // method `foo() {}` + candidates.push(member); + } + else if (ts.isPropertyDeclaration(member)) { + // property `foo = 234` + candidates.push(member); + } + else if (ts.isGetAccessor(member)) { + // getter: `get foo() { ... }` + candidates.push(member); + } + else if (ts.isSetAccessor(member)) { + // setter: `set foo() { ... }` + candidates.push(member); + } + else if (ts.isConstructorDeclaration(member)) { + // constructor-prop:`constructor(private foo) {}` + for (const param of member.parameters) { + if (hasModifier(param, ts.SyntaxKind.PrivateKeyword) + || hasModifier(param, ts.SyntaxKind.ProtectedKeyword) + || hasModifier(param, ts.SyntaxKind.PublicKeyword) + || hasModifier(param, ts.SyntaxKind.ReadonlyKeyword)) { + candidates.push(param); + } + } + } + } + for (const member of candidates) { + const ident = ClassData._getMemberName(member); + if (!ident) { + continue; + } + const symbol = checker.getSymbolAtLocation(member.name); + if (!symbol) { + throw new Error(`NO SYMBOL for ${node.getText()}`); + } + const type = ClassData._getFieldType(member); + this.fields.set(ident, { type, symbol, pos: member.name.pos }); + } + } + static _getMemberName(node) { + if (!node.name) { + return undefined; + } + const { name } = node; + let ident = name.getText(); + if (name.kind === ts.SyntaxKind.ComputedPropertyName) { + if (name.expression.kind !== ts.SyntaxKind.StringLiteral) { + // unsupported: [Symbol.foo] or [abc + 'field'] + return; + } + // ['foo'] + ident = name.expression.getText().slice(1, -1); + } + return ident; + } + static _getFieldType(node) { + if (hasModifier(node, ts.SyntaxKind.PrivateKeyword)) { + return 2 /* FieldType.Private */; + } + else if (hasModifier(node, ts.SyntaxKind.ProtectedKeyword)) { + return 1 /* FieldType.Protected */; + } + else { + return 0 /* FieldType.Public */; + } + } + static _shouldMangle(type) { + return type === 2 /* FieldType.Private */; + } + static fillInReplacement(data) { + if (data.replacements) { + // already done + return; + } + // check with parent + if (data.parent) { + ClassData.fillInReplacement(data.parent); + } + // full chain + const classAndAllParents = []; + let node = data; + while (node) { + classAndAllParents.push(node); + node = node.parent; + } + const identPool = new ShortIdent(name => { + // parents + let node = data.parent; + while (node) { + if (node.isNameTaken(name)) { + return true; + } + node = node.parent; + } + // children + if (data.children) { + const stack = [...data.children]; + while (stack.length) { + const node = stack.pop(); + if (node.isNameTaken(name)) { + return true; + } + if (node.children) { + stack.push(...node.children); + } + } + } + // self + return data.isNameTaken(name); + }); + data.replacements = new Map(); + for (const [name, info] of data.fields) { + if (ClassData._shouldMangle(info.type)) { + const shortName = identPool.next(); + data.replacements.set(name, shortName); + } + } + } + // a name is taken when a field that doesn't get mangled exists or + // when the name is already in use for replacement + isNameTaken(name) { + if (this.fields.has(name) && !ClassData._shouldMangle(this.fields.get(name).type)) { + // public field + return true; + } + if (this.replacements) { + for (const shortName of this.replacements.values()) { + if (shortName === name) { + // replaced already (happens wih super types) + return true; + } + } + } + if (this.node.getSourceFile().identifiers instanceof Map) { + // taken by any other + if (this.node.getSourceFile().identifiers.has(name)) { + return true; + } + } + return false; + } + // --- parent chaining + _addChild(child) { + this.children ??= []; + this.children.push(child); + child.parent = this; + } + static setupParents(data) { + const extendsClause = data.node.heritageClauses?.find(h => h.token === ts.SyntaxKind.ExtendsKeyword); + if (!extendsClause) { + // no EXTENDS-clause + return; + } + const extendsSymbol = getSuperType(extendsClause.types[0].expression); + if (!extendsSymbol) { + // IGNORE: failed to find super-class + return; + } + const parent = allClassDataBySymbol.get(extendsSymbol); + parent?._addChild(data); + } +} +function visit(node) { + if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { + if (node.members.length === 0) { + // IGNORE: no members + return; + } + const classSymbol = checker.getTypeAtLocation(node.name ?? node).symbol; + if (!classSymbol) { + throw new Error('MISSING'); + } + if (allClassDataBySymbol.has(classSymbol)) { + throw new Error('DUPE?'); + } + allClassDataBySymbol.set(classSymbol, new ClassData(node.getSourceFile().fileName, node, classSymbol)); + } + ts.forEachChild(node, visit); +} +// --- ast utils +function hasModifier(node, kind) { + const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined; + return Boolean(modifiers?.find(mode => mode.kind === kind)); +} +function getSuperType(node) { + const type = checker.getTypeAtLocation(node); + if (!type.symbol) { + return; + } + if (!type.symbol.declarations || type.symbol.declarations.length !== 1) { + return; + } + const dec = type.symbol.declarations[0]; + if (dec.kind === ts.SyntaxKind.ClassDeclaration) { + return type.symbol; + } + return undefined; +} +// step 1: collect all class data and store it by symbols +// step 2: hook up extends-chaines and populate field replacement maps +// step 3: generate and apply rewrites +async function mangle() { + // (1) find all classes and field info + for (const file of program.getSourceFiles()) { + if (!file.isDeclarationFile) { + ts.forEachChild(file, visit); + } + } + console.log(`done COLLECTING ${allClassDataBySymbol.size} classes`); + // (1.1) connect all class info + for (const data of allClassDataBySymbol.values()) { + ClassData.setupParents(data); + } + // (2) fill in replacement strings + for (const data of allClassDataBySymbol.values()) { + ClassData.fillInReplacement(data); + } + console.log(`done creating REPLACEMENTS`); + const editsByFile = new Map(); + const appendEdit = (fileName, edit) => { + const edits = editsByFile.get(fileName); + if (!edits) { + editsByFile.set(fileName, [edit]); + } + else { + edits.push(edit); + } + }; + for (const data of allClassDataBySymbol.values()) { + if (hasModifier(data.node, ts.SyntaxKind.DeclareKeyword)) { + continue; + } + for (const [name, info] of data.fields) { + if (!ClassData._shouldMangle(info.type)) { + continue; + } + const newText = data.replacements.get(name); + const locations = service.findRenameLocations(data.fileName, info.pos, false, false, true) ?? []; + for (const loc of locations) { + appendEdit(loc.fileName, { + newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), + offset: loc.textSpan.start, + length: loc.textSpan.length + }); + } + } + } + console.log(`done preparing EDITS for ${editsByFile.size} files`); + // (4) apply renames + let savedBytes = 0; + for (const item of program.getSourceFiles()) { + let newFullText; + const edits = editsByFile.get(item.fileName); + if (!edits) { + // just copy + newFullText = item.getFullText(); + } + else { + // apply renames + edits.sort((a, b) => b.offset - a.offset); + const characters = item.getFullText().split(''); + let lastEdit; + for (const edit of edits) { + if (lastEdit) { + if (lastEdit.offset === edit.offset) { + // + if (lastEdit.length !== edit.length || lastEdit.newText !== edit.newText) { + console.log('OVERLAPPING edit', item.fileName, edit.offset, edits); + throw new Error('OVERLAPPING edit'); + } + else { + continue; + } + } + } + lastEdit = edit; + const removed = characters.splice(edit.offset, edit.length, edit.newText); + savedBytes += removed.length - edit.newText.length; + } + newFullText = characters.join(''); + } + const projectBase = (0, path_1.dirname)(projectPath); + const newProjectBase = (0, path_1.join)((0, path_1.dirname)(projectBase), (0, path_1.basename)(projectBase) + '-mangle'); + const newFilePath = (0, path_1.join)(newProjectBase, (0, path_1.relative)(projectBase, item.fileName)); + await fs.promises.mkdir((0, path_1.dirname)(newFilePath), { recursive: true }); + await fs.promises.writeFile(newFilePath, newFullText); + } + console.log(`DONE saved ${savedBytes / 1000}kb`); +} +mangle(); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mangleTypeScript.js","sourceRoot":"","sources":["mangleTypeScript.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/build/lib/mangleTypeScript.ts b/build/lib/mangleTypeScript.ts new file mode 100644 index 00000000000..a2c9e0d21bb --- /dev/null +++ b/build/lib/mangleTypeScript.ts @@ -0,0 +1,495 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import * as ts from 'typescript'; +import { error } from 'fancy-log'; +import { basename, dirname, join, relative } from 'path'; +import * as fs from 'fs'; + +class ShortIdent { + + private static _keywords = new Set(['await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', + 'default', 'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', + 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return', 'static', 'super', 'switch', 'this', 'throw', + 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']); + + static alphabet: string[] = []; + + static { + for (let i = 97; i < 122; i++) { + this.alphabet.push(String.fromCharCode(i)); + } + for (let i = 65; i < 90; i++) { + this.alphabet.push(String.fromCharCode(i)); + } + } + + + private _value = 0; + + private readonly _isNameTaken: (name: string) => boolean; + + constructor(isNameTaken: (name: string) => boolean) { + this._isNameTaken = name => { + return ShortIdent._keywords.has(name) || isNameTaken(name); + }; + } + + next(): string { + const candidate = ShortIdent.convert(this._value); + this._value++; + if (this._isNameTaken(candidate)) { + // try again + return this.next(); + } + return candidate; + } + + private static convert(n: number): string { + const base = this.alphabet.length; + let result = ''; + do { + const rest = n % 50; + result += this.alphabet[rest]; + n = (n / base) | 0; + } while (n > 0); + return result; + } +} + +const projectPath = 1 + ? join(__dirname, '../../src/tsconfig.json') + : '/Users/jrieken/Code/_samples/3wm/mangePrivate/tsconfig.json'; + +const existingOptions: Partial = {}; + +const parsed = ts.readConfigFile(projectPath, ts.sys.readFile); +if (parsed.error) { + console.log(error); + throw parsed.error; +} + +const cmdLine = ts.parseJsonConfigFileContent(parsed.config, ts.sys, dirname(projectPath), existingOptions); +if (cmdLine.errors.length > 0) { + console.log(error); + throw parsed.error; +} + + +const host = new class implements ts.LanguageServiceHost { + + private _scriptSnapshots: Map = new Map(); + + getCompilationSettings(): ts.CompilerOptions { + return cmdLine.options; + } + getScriptFileNames(): string[] { + return cmdLine.fileNames; + } + getScriptVersion(_fileName: string): string { + return '1'; + } + getProjectVersion(): string { + return '1'; + } + getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined { + let result: ts.IScriptSnapshot | undefined = this._scriptSnapshots.get(fileName); + if (result === undefined) { + const content = ts.sys.readFile(fileName); + if (content === undefined) { + return undefined; + } + result = ts.ScriptSnapshot.fromString(content); + this._scriptSnapshots.set(fileName, result); + } + return result; + } + getCurrentDirectory(): string { + return dirname(projectPath); + } + getDefaultLibFileName(options: ts.CompilerOptions): string { + return ts.getDefaultLibFilePath(options); + } + directoryExists = ts.sys.directoryExists; + getDirectories = ts.sys.getDirectories; + fileExists = ts.sys.fileExists; + readFile = ts.sys.readFile; + readDirectory = ts.sys.readDirectory; + // this is necessary to make source references work. + realpath = ts.sys.realpath; +}; + + +const allClassDataBySymbol = new Map(); +const service = ts.createLanguageService(host); +const program = service.getProgram()!; +const checker = program.getTypeChecker(); + +const enum FieldType { + Public, + Protected, + Private +} + +class ClassData { + + fields = new Map(); + + replacements: Map | undefined; + + parent: ClassData | undefined; + children: ClassData[] | undefined; + + constructor( + readonly fileName: string, + readonly node: ts.ClassDeclaration | ts.ClassExpression, + readonly symbol: ts.Symbol, + ) { + // analyse all fields (properties and methods). Find usages of all protected and + // private ones and keep track of all public ones (to prevent naming collisions) + + const candidates: (ts.NamedDeclaration)[] = []; + for (const member of node.members) { + if (ts.isMethodDeclaration(member)) { + // method `foo() {}` + candidates.push(member); + + } else if (ts.isPropertyDeclaration(member)) { + // property `foo = 234` + candidates.push(member); + + } else if (ts.isGetAccessor(member)) { + // getter: `get foo() { ... }` + candidates.push(member); + + } else if (ts.isSetAccessor(member)) { + // setter: `set foo() { ... }` + candidates.push(member); + + } else if (ts.isConstructorDeclaration(member)) { + // constructor-prop:`constructor(private foo) {}` + for (const param of member.parameters) { + if (hasModifier(param, ts.SyntaxKind.PrivateKeyword) + || hasModifier(param, ts.SyntaxKind.ProtectedKeyword) + || hasModifier(param, ts.SyntaxKind.PublicKeyword) + || hasModifier(param, ts.SyntaxKind.ReadonlyKeyword) + ) { + candidates.push(param); + } + } + } + } + for (const member of candidates) { + const ident = ClassData._getMemberName(member); + if (!ident) { + continue; + } + const symbol = checker.getSymbolAtLocation(member.name!); + if (!symbol) { + throw new Error(`NO SYMBOL for ${node.getText()}`); + } + const type = ClassData._getFieldType(member); + this.fields.set(ident, { type, symbol, pos: member.name!.pos }); + } + } + + private static _getMemberName(node: ts.NamedDeclaration): string | undefined { + if (!node.name) { + return undefined; + } + const { name } = node; + let ident = name.getText(); + if (name.kind === ts.SyntaxKind.ComputedPropertyName) { + if (name.expression.kind !== ts.SyntaxKind.StringLiteral) { + // unsupported: [Symbol.foo] or [abc + 'field'] + return; + } + // ['foo'] + ident = name.expression.getText().slice(1, -1); + } + + return ident; + } + + private static _getFieldType(node: ts.Node): FieldType { + if (hasModifier(node, ts.SyntaxKind.PrivateKeyword)) { + return FieldType.Private; + } else if (hasModifier(node, ts.SyntaxKind.ProtectedKeyword)) { + return FieldType.Protected; + } else { + return FieldType.Public; + } + } + + static _shouldMangle(type: FieldType): boolean { + return type === FieldType.Private; + } + + static fillInReplacement(data: ClassData) { + + if (data.replacements) { + // already done + return; + } + + // check with parent + if (data.parent) { + ClassData.fillInReplacement(data.parent); + } + + // full chain + const classAndAllParents: ClassData[] = []; + let node: ClassData | undefined = data; + while (node) { + classAndAllParents.push(node); + node = node.parent; + } + + const identPool = new ShortIdent(name => { + + // parents + let node: ClassData | undefined = data.parent; + while (node) { + if (node.isNameTaken(name)) { + return true; + } + node = node.parent; + } + + // children + if (data.children) { + const stack = [...data.children]; + while (stack.length) { + const node = stack.pop()!; + if (node.isNameTaken(name)) { + return true; + } + if (node.children) { + stack.push(...node.children); + } + } + } + + // self + return data.isNameTaken(name); + }); + + data.replacements = new Map(); + + for (const [name, info] of data.fields) { + if (ClassData._shouldMangle(info.type)) { + const shortName = identPool.next(); + data.replacements.set(name, shortName); + } + } + } + + // a name is taken when a field that doesn't get mangled exists or + // when the name is already in use for replacement + isNameTaken(name: string) { + if (this.fields.has(name) && !ClassData._shouldMangle(this.fields.get(name)!.type)) { + // public field + return true; + } + if (this.replacements) { + for (const shortName of this.replacements.values()) { + if (shortName === name) { + // replaced already (happens wih super types) + return true; + } + } + } + if ((this.node.getSourceFile()).identifiers instanceof Map) { + // taken by any other + if ((this.node.getSourceFile()).identifiers.has(name)) { + return true; + } + } + return false; + } + + // --- parent chaining + + private _addChild(child: ClassData) { + this.children ??= []; + this.children.push(child); + child.parent = this; + } + + static setupParents(data: ClassData) { + const extendsClause = data.node.heritageClauses?.find(h => h.token === ts.SyntaxKind.ExtendsKeyword); + if (!extendsClause) { + // no EXTENDS-clause + return; + } + const extendsSymbol = getSuperType(extendsClause.types[0].expression); + if (!extendsSymbol) { + // IGNORE: failed to find super-class + return; + } + const parent = allClassDataBySymbol.get(extendsSymbol); + parent?._addChild(data); + } +} + +function visit(node: ts.Node): void { + + if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) { + + if (node.members.length === 0) { + // IGNORE: no members + return; + } + + const classSymbol = checker.getTypeAtLocation(node.name ?? node).symbol; + if (!classSymbol) { + throw new Error('MISSING'); + } + if (allClassDataBySymbol.has(classSymbol)) { + throw new Error('DUPE?'); + } + + allClassDataBySymbol.set(classSymbol, new ClassData(node.getSourceFile().fileName, node, classSymbol)); + } + + ts.forEachChild(node, visit); +} + + +// --- ast utils + + +function hasModifier(node: ts.Node, kind: ts.SyntaxKind) { + const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined; + return Boolean(modifiers?.find(mode => mode.kind === kind)); +} + +function getSuperType(node: ts.Node): ts.Symbol | undefined { + const type = checker.getTypeAtLocation(node); + if (!type.symbol) { + return; + } + if (!type.symbol.declarations || type.symbol.declarations.length !== 1) { + return; + } + const dec = type.symbol.declarations[0]; + if (dec.kind === ts.SyntaxKind.ClassDeclaration) { + return type.symbol; + } + return undefined; +} + +// step 1: collect all class data and store it by symbols +// step 2: hook up extends-chaines and populate field replacement maps +// step 3: generate and apply rewrites + +async function mangle() { + + // (1) find all classes and field info + for (const file of program.getSourceFiles()) { + if (!file.isDeclarationFile) { + ts.forEachChild(file, visit); + } + } + console.log(`done COLLECTING ${allClassDataBySymbol.size} classes`); + + // (1.1) connect all class info + for (const data of allClassDataBySymbol.values()) { + ClassData.setupParents(data); + } + + // (2) fill in replacement strings + for (const data of allClassDataBySymbol.values()) { + ClassData.fillInReplacement(data); + } + console.log(`done creating REPLACEMENTS`); + + // (3) prepare rename edits + type Edit = { newText: string; offset: number; length: number }; + const editsByFile = new Map(); + + const appendEdit = (fileName: string, edit: Edit) => { + const edits = editsByFile.get(fileName); + if (!edits) { + editsByFile.set(fileName, [edit]); + } else { + edits.push(edit); + } + }; + + for (const data of allClassDataBySymbol.values()) { + + if (hasModifier(data.node, ts.SyntaxKind.DeclareKeyword)) { + continue; + } + + for (const [name, info] of data.fields) { + if (!ClassData._shouldMangle(info.type)) { + continue; + } + const newText = data.replacements!.get(name)!; + const locations = service.findRenameLocations(data.fileName, info.pos, false, false, true) ?? []; + for (const loc of locations) { + appendEdit(loc.fileName, { + newText: (loc.prefixText || '') + newText + (loc.suffixText || ''), + offset: loc.textSpan.start, + length: loc.textSpan.length + }); + } + } + } + + console.log(`done preparing EDITS for ${editsByFile.size} files`); + + // (4) apply renames + let savedBytes = 0; + + for (const item of program.getSourceFiles()) { + + let newFullText: string; + const edits = editsByFile.get(item.fileName); + if (!edits) { + // just copy + newFullText = item.getFullText(); + + } else { + // apply renames + edits.sort((a, b) => b.offset - a.offset); + const characters = item.getFullText().split(''); + + let lastEdit: Edit | undefined; + + for (const edit of edits) { + if (lastEdit) { + if (lastEdit.offset === edit.offset) { + // + if (lastEdit.length !== edit.length || lastEdit.newText !== edit.newText) { + console.log('OVERLAPPING edit', item.fileName, edit.offset, edits); + throw new Error('OVERLAPPING edit'); + } else { + continue; + } + } + } + lastEdit = edit; + const removed = characters.splice(edit.offset, edit.length, edit.newText); + savedBytes += removed.length - edit.newText.length; + } + newFullText = characters.join(''); + } + + const projectBase = dirname(projectPath); + const newProjectBase = join(dirname(projectBase), basename(projectBase) + '-mangle'); + const newFilePath = join(newProjectBase, relative(projectBase, item.fileName)); + + await fs.promises.mkdir(dirname(newFilePath), { recursive: true }); + + await fs.promises.writeFile(newFilePath, newFullText); + } + + console.log(`DONE saved ${savedBytes / 1000}kb`); +} + +mangle();