Method parseClassElement

src/parser.ts:526–575

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

  }

  parseClassElement(classDeclaration: ts.ClassDeclaration,
                    node: ts.ClassElement): syntax.ClassElement {
    switch (node.kind) {
      case ts.SyntaxKind.Constructor: {
        // constructor(xxx) { yyy }
        return this.parseConstructorDeclaration(classDeclaration, node as ts.ConstructorDeclaration);
      }
      case ts.SyntaxKind.PropertyDeclaration: {
        // prop: type = xxx;
        const {modifiers, name, initializer} = node as ts.PropertyDeclaration;
        if (!ts.isIdentifier(name))
          throw new UnimplementedError(name, 'Only identifier can be used as property name');
        return new syntax.PropertyDeclaration(name.text,
                                              modifiers?.map(modifierToString) ?? [],
                                              this.typer.parseNodeType(name),
                                              initializer ? this.parseExpression(initializer) : undefined);
      }
      case ts.SyntaxKind.MethodDeclaration: {
        // method() { xxx }
        const {modifiers, name, body, parameters, questionToken, typeParameters} = node as ts.MethodDeclaration;
        if (!ts.isIdentifier(name))
          throw new UnsupportedError(name, 'Only identifier can be used as method name');
        if (questionToken)
          throw new UnsupportedError(name, 'Can not use question token in method');
        if (typeParameters)
          throw new UnimplementedError(name, 'Generic method is not supported');
        if (modifiers?.find(m => m.kind == ts.SyntaxKind.AsyncKeyword))
          throw new UnimplementedError(node, 'Async function is not supported');
        this.typer.forbidClosure(node as ts.MethodDeclaration);
        const cppModifiers = modifiers?.map(modifierToString) ?? [];
        cppModifiers.push(...parseHint(node));
        // In TypeScript every method is "virtual", while it is possible to
        // lookup all derived classes to decide whether to make the method
        // virtual, it is not worth the efforts.
        if (!cppModifiers.includes('static') &&
            !cppModifiers.includes('override') &&
            !cppModifiers.includes('destructor')) {
          cppModifiers.push('virtual');
        }
        return new syntax.MethodDeclaration(this.typer.parseNodeType(node) as syntax.FunctionType,
                                            name.text,
                                            cppModifiers,
                                            this.parseParameters(parameters),
                                            body ? this.parseStatement(body) as syntax.Block : undefined);
      }
      case ts.SyntaxKind.SemicolonClassElement:
        return new syntax.SemicolonClassElement();
    }
    throw new UnimplementedError(node, 'Unsupported class element');
  }

  parseConstructorDeclaration(classDeclaration: ts.ClassDeclaration, node: ts.ConstructorDeclaration): syntax.ConstructorDeclaration {
    let {body, parameters} = node;