public override newExpression()

in src/languages/java.ts [460:502]
34 lines of code
9 McCabe index (conditional complexity)

  public override newExpression(node: ts.NewExpression, renderer: JavaRenderer): OTree {
    const argsLength = node.arguments ? node.arguments.length : 0;
    const lastArg = argsLength > 0 ? node.arguments![argsLength - 1] : undefined;

    // We render the ClassName.Builder.create(...) expression
    // if the last argument is an object literal, and either a known struct (because
    // those are the jsii rules) or an unknown type (because the example didn't
    // compile but most of the target examples will intend this to be a struct).

    const structArgument = lastArg && ts.isObjectLiteralExpression(lastArg) ? lastArg : undefined;
    let renderBuilder = false;
    if (lastArg && ts.isObjectLiteralExpression(lastArg)) {
      const analysis = analyzeObjectLiteral(renderer.typeChecker, lastArg);
      renderBuilder = analysis.kind === 'struct' || analysis.kind === 'unknown';
    }

    const className = renderer
      .updateContext({
        discardPropertyAccess: true,
        convertPropertyToGetter: false,
      })
      .convert(node.expression);

    if (renderBuilder) {
      const initialArguments = node.arguments!.slice(0, argsLength - 1);
      return new OTree(
        [],
        [
          className,
          '.Builder.create(',
          this.argumentList(initialArguments, renderer),
          ')',
          ...renderer.convertAll(structArgument!.properties),
          new OTree([renderer.mirrorNewlineBefore(structArgument!.properties[0])], ['.build()']),
        ],
        { canBreakLine: true, indent: 8 },
      );
    }

    return new OTree([], ['new ', className, '(', this.argumentList(node.arguments, renderer), ')'], {
      canBreakLine: true,
    });
  }