Method parseFunctionExpression

src/parser.ts:466–496

(node: ts.FunctionExpression | ts.ArrowFunction)

  }

  parseFunctionExpression(node: ts.FunctionExpression | ts.ArrowFunction): syntax.FunctionExpression {
    const {body, parameters, modifiers, asteriskToken, exclamationToken, questionToken, typeParameters} = node;
    if (asteriskToken)
      throw new UnimplementedError(node, 'Generator is not supported');
    if (questionToken)
      throw new UnimplementedError(node, 'Question token in function is not supported');
    if (exclamationToken)
      throw new UnimplementedError(node, 'Exclamation token in function is not supported');
    if (typeParameters)
      throw new UnimplementedError(node, 'Generic function is not supported');
    if (modifiers?.find(m => m.kind == ts.SyntaxKind.AsyncKeyword))
      throw new UnimplementedError(node, 'Async function is not supported');
    let cppBody: undefined | syntax.Block;
    if (body) {
      if (ts.isBlock(body)) {
        cppBody = this.parseStatement(body) as syntax.Block;
      } else {
        // Arrow function may use expression as body, convert it to block.
        cppBody = new syntax.Block([
          new syntax.ReturnStatement(this.parseExpression(body)),
        ]);
      }
    }
    const closure = this.typer.getCapturedIdentifiers(node)
                              .map(n => this.parseExpression(n))
                              .filter(e => e.type.hasObject());
    return new syntax.FunctionExpression(this.typer.parseNodeType(node) as syntax.FunctionType,
                                         parameters.map(this.parseParameterDeclaration.bind(this)),
                                         closure,
                                         cppBody);
  }

  parseParameters(parameters: ts.NodeArray<ts.ParameterDeclaration> | ts.ParameterDeclaration[]): syntax.ParameterDeclaration[] {
    return parameters.map(this.parseParameterDeclaration.bind(this));