[refactoring] Use string interpolation where possible

src/compiler.ts

@@ -2863,7 +2863,7 @@ export class Compiler extends DiagnosticEmitter {
       let case_ = cases[i];
       let label = case_.label;
       if (label) {
-        breaks[breakIndex++] = module.br("case" + i.toString() + "|" + context,
+        breaks[breakIndex++] = module.br(`case${i}|${context}`,
           module.binary(BinaryOp.EqI32,
             module.local_get(tempLocalIndex, NativeType.I32),
             this.compileExpression(label, Type.u32,
@@ -2879,10 +2879,7 @@ export class Compiler extends DiagnosticEmitter {
     outerFlow.freeTempLocal(tempLocal);
 
     // otherwise br to default respectively out of the switch if there is no default case
-    breaks[breakIndex] = module.br((defaultIndex >= 0
-      ? "case" + defaultIndex.toString()
-      : "break"
-    ) + "|" + context);
+    breaks[breakIndex] = module.br(`${(defaultIndex >= 0 ? `case${defaultIndex}` : "break" )}|${context}`);
 
     // nest blocks in order
     var currentBlock = module.block("case0|" + context, breaks, NativeType.None);
@@ -2900,7 +2897,7 @@ export class Compiler extends DiagnosticEmitter {
       innerFlow.breakLabel = breakLabel;
 
       let isLast = i == numCases - 1;
-      let nextLabel = isLast ? breakLabel : "case" + (i + 1).toString() + "|" + context;
+      let nextLabel = isLast ? breakLabel : `case${i + 1}|${context}`;
       let stmts = new Array<ExpressionRef>(1 + numStatements);
       stmts[0] = currentBlock;
       let count = 1;
@@ -6800,7 +6797,7 @@ export class Compiler extends DiagnosticEmitter {
     // create a br_table switching over the number of optional parameters provided
     var numNames = numOptional + 1; // incl. outer block
     var names = new Array<string>(numNames);
-    var ofN = "of" + numOptional.toString();
+    var ofN = `of${numOptional}`;
     for (let i = 0; i < numNames; ++i) {
       let label = i.toString() + ofN;
       names[i] = label;
@@ -7400,7 +7397,7 @@ export class Compiler extends DiagnosticEmitter {
     var isSemanticallyAnonymous = !isNamed || contextualType != Type.void;
     var prototype = new FunctionPrototype(
       isSemanticallyAnonymous
-        ? (isNamed ? declaration.name.text + "|" : "anonymous|") + (actualFunction.nextAnonymousId++).toString()
+        ? `${isNamed ? declaration.name.text + "|" : "anonymous|"}${actualFunction.nextAnonymousId++}`
         : declaration.name.text,
       actualFunction,
       declaration,

src/diagnostics.ts

@@ -142,33 +142,18 @@ export class DiagnosticMessage {
 
   /** Converts this message to a string. */
   toString(): string {
+    var category = diagnosticCategoryToString(this.category);
     var range = this.range;
     if (range) {
       let source = range.source;
-      return (
-        diagnosticCategoryToString(this.category) +
-        " " +
-        this.code.toString() +
-        ": \"" +
-        this.message +
-        "\" in " +
-        source.normalizedPath +
-        "(" +
-        source.lineAt(range.start).toString() +
-        "," +
-        source.columnAt().toString() +
-        "+" +
-        (range.end - range.start).toString() +
-        ")"
-      );
+      let path = source.normalizedPath;
+      let line = source.lineAt(range.start);
+      let column = source.columnAt();
+      let len = range.end - range.start;
+
+      return `${category} ${this.code}: "${this.message}" in ${path}(${line},${column}+${len})`;
     }
-    return (
-      diagnosticCategoryToString(this.category) +
-      " " +
-      this.code.toString() +
-      ": " +
-      this.message
-    );
+    return `${category} ${this.code}: ${this.message}`;
   }
 }
 

src/flow.ts

@@ -198,7 +198,7 @@ export class Flow {
   static createInline(parentFunction: Function, inlineFunction: Function): Flow {
     var flow = new Flow(parentFunction);
     flow.inlineFunction = inlineFunction;
-    flow.inlineReturnLabel = inlineFunction.internalName + "|inlined." + (inlineFunction.nextInlineId++).toString();
+    flow.inlineReturnLabel = `${inlineFunction.internalName}|inlined.${inlineFunction.nextInlineId++}`;
     if (inlineFunction.is(CommonFlags.CONSTRUCTOR)) {
       flow.initThisFieldFlags();
     }
@@ -912,7 +912,7 @@ export class Flow {
         let key = _keys[i];
         let leftFlags = changetype<FieldFlags>(leftFieldFlags.get(key));
         if (
-          (leftFlags & FieldFlags.INITIALIZED) != 0 && rightFieldFlags.has(key) && 
+          (leftFlags & FieldFlags.INITIALIZED) != 0 && rightFieldFlags.has(key) &&
           (changetype<FieldFlags>(rightFieldFlags.get(key)) & FieldFlags.INITIALIZED)
         ) {
           newFieldFlags.set(key, FieldFlags.INITIALIZED);
@@ -1456,7 +1456,7 @@ export class Flow {
     if (this.is(FlowFlags.CONDITIONALLY_CONTINUES)) sb.push("CONDITIONALLY_CONTINUES");
     if (this.is(FlowFlags.CONDITIONALLY_ACCESSES_THIS)) sb.push("CONDITIONALLY_ACCESSES_THIS");
     if (this.is(FlowFlags.MAY_RETURN_NONTHIS)) sb.push("MAY_RETURN_NONTHIS");
-    return "Flow(" + this.actualFunction.toString() + ")[" + levels.toString() + "] " + sb.join(" ");
+    return `Flow(${this.actualFunction})[${levels}] ${sb.join(" ")}`;
   }
 }
 

src/module.ts

@@ -2972,7 +2972,7 @@ export class SwitchBuilder {
     var entry = new Array<ExpressionRef>(1 + numValues + 1);
     var labels = new Array<string>(numCases);
     for (let i = 0; i < numCases; ++i) {
-      labels[i] = "case" + i.toString() + labelPostfix;
+      labels[i] = `case${i}${labelPostfix}`;
     }
     entry[0] = module.local_set(localIndex, this.condition, false); // u32
     for (let i = 0; i < numValues; ++i) {

src/program.ts

@@ -2842,7 +2842,7 @@ export abstract class Element {
 
   /** Returns a string representation of this element. */
   toString(): string {
-    return this.internalName + ", kind=" + this.kind.toString();
+    return `${this.internalName}, kind=${this.kind}`;
   }
 }
 
@@ -3674,9 +3674,7 @@ export class Function extends TypedElement {
     // if it has a name, check previously as this method will throw otherwise
     var localIndex = this.signature.parameterTypes.length + this.additionalLocals.length;
     if (this.is(CommonFlags.INSTANCE)) ++localIndex;
-    var localName = name !== null
-      ? name
-      : "var$" + localIndex.toString();
+    var localName = name !== null ? name : `var$${localIndex}`;
     if (!declaration) declaration = this.program.makeNativeVariableDeclaration(localName);
     var local = new Local(
       localName,
@@ -4763,7 +4761,7 @@ var cachedDefaultParameterNames: string[] = [];
 /** Gets the cached default parameter name for the specified index. */
 export function getDefaultParameterName(index: i32): string {
   for (let i = cachedDefaultParameterNames.length; i <= index; ++i) {
-    cachedDefaultParameterNames.push("$" + i.toString());
+    cachedDefaultParameterNames.push(`$${i}`);
   }
   return cachedDefaultParameterNames[index];
 }

src/resolver.ts

@@ -2760,7 +2760,7 @@ export class Resolver extends DiagnosticEmitter {
     signature.requiredParameters = requiredParameters;
 
     var nameInclTypeParameters = prototype.name;
-    if (instanceKey.length) nameInclTypeParameters += "<" + instanceKey + ">";
+    if (instanceKey.length) nameInclTypeParameters += `<${instanceKey}>`;
     var instance = new Function(
       nameInclTypeParameters,
       prototype,
@@ -2868,7 +2868,7 @@ export class Resolver extends DiagnosticEmitter {
 
     // Otherwise create
     var nameInclTypeParamters = prototype.name;
-    if (instanceKey.length) nameInclTypeParamters += "<" + instanceKey + ">";
+    if (instanceKey.length) nameInclTypeParamters += `<${instanceKey}>`;
     if (prototype.kind == ElementKind.INTERFACE_PROTOTYPE) {
       instance = new Interface(nameInclTypeParamters, <InterfacePrototype>prototype, typeArguments);
     } else {

src/types.ts

@@ -222,7 +222,7 @@ export class Type {
   get isFloatValue(): bool {
     return this.is(TypeFlags.FLOAT | TypeFlags.VALUE);
   }
-  
+
   /** Tests if this type represents a numeric (integer or floating point) value. */
   get isNumericValue(): bool {
     return this.isIntegerValue || this.isFloatValue;
@@ -237,7 +237,7 @@ export class Type {
   get isVectorValue(): bool {
     return this.is(TypeFlags.VECTOR | TypeFlags.VALUE);
   }
-  
+
   /** Tests if this type represents an internal or external reference. */
   get isReference(): bool {
     return this.is(TypeFlags.REFERENCE);
@@ -479,7 +479,7 @@ export class Type {
         let signatureReference = this.getSignature();
         if (signatureReference) {
           return this.isNullableReference
-            ? "(" + signatureReference.toString(validWat) + ")" + nullablePostfix
+            ? `(${signatureReference.toString(validWat)})${nullablePostfix}`
             : signatureReference.toString(validWat);
         }
       }