Replace strings using a slightly faster method.

Improves performance of the demangler considerably, taking one example
case from 30s compilation down to 10s (on my laptop).

With much help from @apmorton

Should help with compiler-explorer#1336, though we still need more work to push stuff
onto another thread to really help with that (per Austin's comments).

Author: mattgodbolt

Diff for: lib/demangler.js

@@ -165,27 +165,18 @@ class Demangler extends AsmRegex {
         for (let i = 0; i < lines.length; ++i)
             this.addTranslation(this.input[i], lines[i]);
 
-        let translations = [];
-        translations = translations.concat(this.symbolstore.listTranslations());
-        translations = translations.concat(this.othersymbols.listTranslations());
+        const translations = [...this.symbolstore.listTranslations(), ...this.othersymbols.listTranslations()];
 
-        for (let i = 0; i < this.result.asm.length; ++i) {
-            let line = this.result.asm[i].text;
-            for (let j = 0; j < translations.length; ++j) {
-                const oldValue = translations[j][0];
-                const newValue = translations[j][1];
-
-                line = line.replace(oldValue, newValue);
-                line = line.replace(oldValue, newValue);
-
-                this.demangleLabels(this.result.asm[i].labels,
-                    oldValue, newValue);
+        for (const asm of this.result.asm) {
+            let line = asm.text;
+            for (const [oldValue, newValue] of translations) {
+                line = utils.replaceAll(line, oldValue, newValue);
+                this.demangleLabels(asm.labels, oldValue, newValue);
             }
-            this.result.asm[i].text = line;
+            asm.text = line;
         }
 
-        this.demangleLabelDefinitions(
-            this.result.labelDefinitions, translations);
+        this.demangleLabelDefinitions(this.result.labelDefinitions, translations);
 
         return this.result;
     }

Diff for: lib/utils.js

@@ -205,3 +205,18 @@ exports.toProperty = function toProperty(prop) {
     if (prop.match(/^-?[0-9]*\.[0-9]+$/)) return parseFloat(prop);
     return prop;
 };
+
+// This function replaces all the "oldValues" in line with "newValue". It handles overlapping string replacement cases,
+// and is careful to return the exact same line object if there's no matches. This turns out to be super important for
+// performance.
+exports.replaceAll = function replaceAll(line, oldValue, newValue) {
+    if (oldValue.length === 0) return line;
+    let startPoint = 0;
+    for (; ;) {
+        const index = line.indexOf(oldValue, startPoint);
+        if (index === -1) break;
+        line = line.substr(0, index) + newValue + line.substr(index + oldValue.length);
+        startPoint = index + newValue.length;
+    }
+    return line;
+};

Diff for: test/utils-tests.js

@@ -319,3 +319,34 @@ describe('squashes horizontal whitespace', () => {
         utils.squashHorizontalWhitespace('    abc   abc').should.equals('  abc abc');
     });
 });
+
+describe('replaces all substrings', () => {
+    it('works with no substitutions', () => {
+        const string = "This is a line with no replacements";
+        utils.replaceAll(string, "not present", "won't be substituted").should.equal(string);
+    });
+    it('handles odd cases', () => {
+        utils.replaceAll("", "", "").should.equal("");
+        utils.replaceAll("Hello", "", "").should.equal("Hello");
+    });
+    it('works with single replacement', () => {
+        utils.replaceAll("This is a line with a mistook in it", "mistook", "mistake")
+            .should.equal("This is a line with a mistake in it");
+        utils.replaceAll("This is a line with a mistook", "mistook", "mistake")
+            .should.equal("This is a line with a mistake");
+        utils.replaceAll("Mistooks were made", "Mistooks", "Mistakes")
+            .should.equal("Mistakes were made");
+    });
+
+    it('works with multiple replacements', () => {
+        utils.replaceAll("A mistook is a mistook", "mistook", "mistake")
+            .should.equal("A mistake is a mistake");
+        utils.replaceAll("aaaaaaaaaaaaaaaaaaaaaaaaaaa", "a", "b")
+            .should.equal("bbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    });
+
+    it('works with overlapping replacements', () => {
+        utils.replaceAll("aaaaaaaa", "a", "ba")
+            .should.equal("babababababababa");
+    });
+});