Fix crash when access modifiers are used in constructor param defaults (

#531)

Fixes #522

Previously, the logic to compile TS constructor param assignments walked through
all tokens in the constructor looking for access modifiers, but this can cause
problems if default values include access modifiers. Now, we mark commas
associated with the constructor and only emit assignments when we see an
open-paren or comma followed by an access modifier.

src/parser/traverser/lval.ts

@@ -86,6 +86,7 @@ export function parseBindingList(
   isBlockScope: boolean,
   allowEmpty: boolean = false,
   allowModifiers: boolean = false,
+  contextId: number = 0,
 ): void {
   let first = true;
 
@@ -97,6 +98,7 @@ export function parseBindingList(
       first = false;
     } else {
       expect(tt.comma);
+      state.tokens[state.tokens.length - 1].contextId = contextId;
       // After a "this" type in TypeScript, we need to set the following comma (if any) to also be
       // a type token so that it will be removed.
       if (!hasRemovedComma && state.tokens[firstItemTokenIndex].isType) {

src/parser/traverser/statement.ts

@@ -614,7 +614,13 @@ export function parseFunctionParams(
   if (funcContextId) {
     state.tokens[state.tokens.length - 1].contextId = funcContextId;
   }
-  parseBindingList(tt.parenR, false /* isBlockScope */, false /* allowEmpty */, allowModifiers);
+  parseBindingList(
+    tt.parenR,
+    false /* isBlockScope */,
+    false /* allowEmpty */,
+    allowModifiers,
+    funcContextId,
+  );
   if (funcContextId) {
     state.tokens[state.tokens.length - 1].contextId = funcContextId;
   }

src/util/getClassInfo.ts

@@ -197,22 +197,27 @@ function processConstructor(
   if (constructorContextId == null) {
     throw new Error("Expected context ID on open-paren starting constructor params.");
   }
-  tokens.nextToken();
   // Advance through parameters looking for access modifiers.
   while (!tokens.matchesContextIdAndLabel(tt.parenR, constructorContextId)) {
-    if (isAccessModifier(tokens.currentToken())) {
+    if (tokens.currentToken().contextId === constructorContextId) {
+      // Current token is an open paren or comma just before a param, so check
+      // that param for access modifiers.
       tokens.nextToken();
-      while (isAccessModifier(tokens.currentToken())) {
+      if (isAccessModifier(tokens.currentToken())) {
         tokens.nextToken();
+        while (isAccessModifier(tokens.currentToken())) {
+          tokens.nextToken();
+        }
+        const token = tokens.currentToken();
+        if (token.type !== tt.name) {
+          throw new Error("Expected identifier after access modifiers in constructor arg.");
+        }
+        const name = tokens.identifierNameForToken(token);
+        constructorInitializerStatements.push(`this.${name} = ${name}`);
       }
-      const token = tokens.currentToken();
-      if (token.type !== tt.name) {
-        throw new Error("Expected identifier after access modifiers in constructor arg.");
-      }
-      const name = tokens.identifierNameForToken(token);
-      constructorInitializerStatements.push(`this.${name} = ${name}`);
+    } else {
+      tokens.nextToken();
     }
-    tokens.nextToken();
   }
   // )
   tokens.nextToken();

test/typescript-test.ts

@@ -1974,4 +1974,34 @@ describe("typescript transform", () => {
     `,
     );
   });
+
+  it("properly handles default args in constructors", () => {
+    assertTypeScriptResult(
+      `
+      class Foo {
+        constructor(p = -1) {}
+      }
+    `,
+      `"use strict";
+      class Foo {
+        constructor(p = -1) {}
+      }
+    `,
+    );
+  });
+
+  it("properly emits assignments with multiple constructor initializers", () => {
+    assertTypeScriptResult(
+      `
+      class Foo {
+        constructor(a: number, readonly b: number, private c: number) {}
+      }
+    `,
+      `"use strict";
+      class Foo {
+        constructor(a,  b,  c) {;this.b = b;this.c = c;}
+      }
+    `,
+    );
+  });
 });