More use of string templates in parseTools.js. NFC (#20431)

Author: sbc100

src/parseTools.js

@@ -23,7 +23,7 @@ function processMacros(text) {
       const ret = eval(str);
       return ret !== null ? ret.toString() : '';
     } catch (ex) {
-      ex.stack = 'In the following macro:\n\n' + str + '\n\n' + ex.stack;
+      ex.stack = `In the following macro:\n\n${str}\n\n${ex.stack}`;
       throw ex;
     }
   });
@@ -178,7 +178,7 @@ function needsQuoting(ident) {
 global.POINTER_SIZE = MEMORY64 ? 8 : 4;
 global.STACK_ALIGN = 16;
 const POINTER_BITS = POINTER_SIZE * 8;
-const POINTER_TYPE = 'u' + POINTER_BITS;
+const POINTER_TYPE = `u${POINTER_BITS}`;
 const POINTER_JS_TYPE = MEMORY64 ? "'bigint'" : "'number'";
 const POINTER_SHIFT = MEMORY64 ? '3' : '2';
 const POINTER_HEAP = MEMORY64 ? 'HEAP64' : 'HEAP32';
@@ -190,7 +190,7 @@ const SIZE_TYPE = POINTER_TYPE;
 // used in practice, while POINTER_TYPE is the more refined internal
 // type (that is unsigned, where as core wasm does not have unsigned
 // types).
-const POINTER_WASM_TYPE = 'i' + POINTER_BITS;
+const POINTER_WASM_TYPE = `i${POINTER_BITS}`;
 
 function isPointerType(type) {
   return type[type.length - 1] == '*';
@@ -201,10 +201,10 @@ function isPointerType(type) {
 // value will be replaced with tempVar.
 function makeInlineCalculation(expression, value, tempVar) {
   if (!isNiceIdent(value)) {
-    expression = tempVar + '=' + value + ',' + expression;
+    expression = `${tempVar} = ${value},${expression}`;
     value = tempVar;
   }
-  return '(' + expression.replace(/VALUE/g, value) + ')';
+  return `(${expression.replace(/VALUE/g, value)})`;
 }
 
 // XXX Make all i64 parts signed
@@ -264,7 +264,7 @@ function indentify(text, indent) {
       indent += ' ';
     }
   }
-  return text.replace(/\n/g, '\n' + indent);
+  return text.replace(/\n/g, `\n${indent}`);
 }
 
 // Correction tools
@@ -283,7 +283,7 @@ function getNativeTypeSize(type) {
       }
       if (type[0] === 'i') {
         const bits = Number(type.substr(1));
-        assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);
+        assert(bits % 8 === 0, `getNativeTypeSize invalid bits ${bits}, ${type} type`);
         return bits / 8;
       }
       return 0;
@@ -322,7 +322,7 @@ function asmEnsureFloat(value, type) {
     // may need a .0 (if it can't fit in an int)
     if (value == 0) return 'Math.fround(0)';
     value = ensureDot(value);
-    return 'Math.fround(' + value + ')';
+    return `Math.fround(${value})`;
   }
   if (FLOAT_TYPES.has(type)) {
     return ensureDot(value);
@@ -340,15 +340,15 @@ function asmCoercion(value, type) {
       return asmEnsureFloat(value, type);
     }
     if (type === 'float') {
-      return 'Math.fround(' + value + ')';
+      return `Math.fround(${value})`;
     }
-    return '(+(' + value + '))';
+    return `(+(${value}))`;
   }
-  return '((' + value + ')|0)';
+  return `((${value})|0)`;
 }
 
 function asmFloatToInt(x) {
-  return '(~~(' + x + '))';
+  return `(~~(${x}))`;
 }
 
 // See makeSetValue
@@ -359,7 +359,7 @@ function makeGetValue(ptr, pos, type, noNeedFirst, unsigned, ignore, align) {
     // TODO(sbc): make this into an error at some point.
     printErr('makeGetValue: Please use u8/u16/u32/u64 unsigned types in favor of additional argument');
     if (unsigned && type.startsWith('i')) {
-      type = 'u' + type.slice(1);
+      type = `u${type.slice(1)}`;
     }
   } else if (type.startsWith('u')) {
     // Set `unsigned` based on the type name.
@@ -368,11 +368,11 @@ function makeGetValue(ptr, pos, type, noNeedFirst, unsigned, ignore, align) {
 
   const offset = calcFastOffset(ptr, pos);
   if (type === 'i53' || type === 'u53') {
-    return 'readI53From' + (unsigned ? 'U' : 'I') + '64(' + offset + ')';
+    return `readI53From${unsigned ? 'U' : 'I'}64(${offset})`;
   }
 
   const slab = getHeapForType(type);
-  let ret = slab + '[' + getHeapOffset(offset, type) + ']';
+  let ret = `${slab}[${getHeapOffset(offset, type)}]`;
   if (MEMORY64 && isPointerType(type)) {
     ret = `Number(${ret})`;
   }
@@ -395,7 +395,7 @@ function makeSetValue(ptr, pos, value, type) {
   if (ASSERTIONS == 2 && (type.startsWith('i') || type.startsWith('u'))) {
     const width = getBitWidth(type);
     const assertion = `checkInt${width}(${value})`;
-    rtn += ';' + assertion
+    rtn += `;${assertion}`
   }
   return rtn;
 }
@@ -419,7 +419,7 @@ function makeSetValueImpl(ptr, pos, value, type) {
   if (slab == 'HEAPU64' || slab == 'HEAP64') {
     value = `BigInt(${value})`;
   }
-  return slab + '[' + getHeapOffset(offset, type) + '] = ' + value;
+  return `${slab}[${getHeapOffset(offset, type)}] = ${value}`;
 }
 
 function makeHEAPView(which, start, end) {
@@ -517,7 +517,7 @@ function getHeapForType(type) {
     case 'i64':    // fallthrough
     case 'u64':    error('use i53/u53, or avoid i64/u64 without WASM_BIGINT');
   }
-  assert(false, 'bad heap type: ' + type);
+  assert(false, `bad heap type: ${type}`);
 }
 
 function makeReturn64(value) {
@@ -726,20 +726,16 @@ function modifyJSFunction(text, func) {
 
 function runIfMainThread(text) {
   if (WASM_WORKERS && PTHREADS) {
-    return 'if (!ENVIRONMENT_IS_WASM_WORKER && !ENVIRONMENT_IS_PTHREAD) { ' + text + ' }';
+    return `if (!ENVIRONMENT_IS_WASM_WORKER && !ENVIRONMENT_IS_PTHREAD) { ${text} }`;
   } else if (WASM_WORKERS) {
-    return 'if (!ENVIRONMENT_IS_WASM_WORKER) { ' + text + ' }';
+    return `if (!ENVIRONMENT_IS_WASM_WORKER) { ${text} }`;
   } else if (PTHREADS) {
-    return 'if (!ENVIRONMENT_IS_PTHREAD) { ' + text + ' }';
+    return `if (!ENVIRONMENT_IS_PTHREAD) { ${text} }`;
   } else {
     return text;
   }
 }
 
-// Legacy name for runIfMainThread.
-// TODO(remove).
-const runOnMainThread = runIfMainThread;
-
 function expectToReceiveOnModule(name) {
   return INCOMING_MODULE_JS_API.has(name);
 }
@@ -794,17 +790,17 @@ function makeModuleReceiveExpr(name, defaultValue) {
 function makeModuleReceiveWithVar(localName, moduleName, defaultValue, noAssert) {
   if (!moduleName) moduleName = localName;
   checkReceiving(moduleName);
-  let ret = 'var ' + localName;
+  let ret = `var ${localName}`;
   if (!expectToReceiveOnModule(moduleName)) {
     if (defaultValue) {
-      ret += ' = ' + defaultValue;
+      ret += ` = ${defaultValue}`;
     }
     ret += ';';
   } else {
     if (defaultValue) {
       ret += ` = Module['${moduleName}'] || ${defaultValue};`;
     } else {
-      ret += ';' + makeModuleReceive(localName, moduleName);
+      ret += `; ${makeModuleReceive(localName, moduleName)}`;
       return ret;
     }
   }
@@ -817,7 +813,7 @@ function makeModuleReceiveWithVar(localName, moduleName, defaultValue, noAssert)
 function makeRemovedFSAssert(fsName) {
   assert(ASSERTIONS);
   const lower = fsName.toLowerCase();
-  if (JS_LIBRARIES.includes('library_' + lower + '.js')) return '';
+  if (JS_LIBRARIES.includes(`library_${lower}.js`)) return '';
   return `var ${fsName} = '${fsName} is no longer included by default; build with -l${lower}.js';`;
 }
 
@@ -853,7 +849,7 @@ function _asmjsDemangle(symbol) {
     return symbol;
   }
   // Strip leading "_"
-  assert(symbol.startsWith('_'), 'expected mangled symbol: ' + symbol);
+  assert(symbol.startsWith('_'), `expected mangled symbol: ${symbol}`);
   return symbol.substr(1);
 }
 
@@ -1010,7 +1006,7 @@ function getEntryFunction() {
   if (MAIN_MODULE) {
     return `resolveGlobalSymbol('${entryFunction}').sym;`
   }
-  return '_' + entryFunction;
+  return `_${entryFunction}`;
 }
 
 function preJS() {

src/parseTools_legacy.js

@@ -132,3 +132,6 @@ function asmFFICoercion(value, type) {
   if (type === 'float') value = asmCoercion(value, 'float');
   return value;
 }
+
+// Legacy name for runIfMainThread.
+const runOnMainThread = runIfMainThread;