Method parseConstructorDeclaration

src/parser.ts:577–603

(classDeclaration: ts.ClassDeclaration, node: ts.ConstructorDeclaration)

  }

  parseConstructorDeclaration(classDeclaration: ts.ClassDeclaration, node: ts.ConstructorDeclaration): syntax.ConstructorDeclaration {
    let {body, parameters} = node;
    this.typer.forbidClosure(node as ts.ConstructorDeclaration);
    let baseCall: syntax.CallArguments | undefined;
    if (body) {
      // The super call can only be used as the first statement.
      const superCall = filterNode(body, (node) => ts.isCallExpression(node) && node.expression.kind == ts.SyntaxKind.SuperKeyword) as ts.CallExpression[];
      if (superCall.length == 1) {
        const firstStatement = body.statements[0];
        if (!ts.isExpressionStatement(firstStatement) ||
            !ts.isCallExpression(firstStatement.expression) ||
            superCall[0] != firstStatement.expression) {
          throw new UnimplementedError(superCall[0], 'The super call must be placed as the first statement in body');
        }
        // Convert the super call to C++.
        baseCall = this.parseArguments(superCall[0], superCall[0]['arguments']);
        // Remove the super call from body.
        body = ts.factory.createBlock(body.statements.slice(1));
      } else if (superCall.length > 1) {
        throw new UnimplementedError(superCall[1], 'The super call can only be called once');
      }
    }
    return new syntax.ConstructorDeclaration(classDeclaration.name!.text,
                                             this.parseParameters(parameters),
                                             body ? this.parseStatement(body) as syntax.Block : undefined,
                                             baseCall);
  }

  parseObjectLiteral(node: ts.ObjectLiteralExpression): syntax.ObjectLiteral {
    const initializers = new Map<string, syntax.Expression>();