Variables of kind `ConditionalExpression` have defaultValue set to condition

[nicknisi]

Given the following TypeScript code, TypeDoc produces some incorrect output.

Source File:

/**
 * some function
 * @param str some string
 * @returns true or false
 */
export const assign = has('something') ? function(str: string): boolean { return true; } : function (str: string): boolean { return false; };

Output:

What seems to be happening is that this is going through the variable converter, and inside of the switch statement, the node.initializer.kind value is 193 ("ConditionalExpression"). This means that it hits the default portion of the switch statement and sets the whole conditional as the defaultValue, which seems incorrect given TypeScript can determine the type for the conditional expression.

I know that TypeScript can determine what the actual type is for the assign variable.

context.checker.typeToString(context.checker.getTypeAtLocation(node.initializer))

I'm looking into how TypeDoc can infer this as well. What I am initially looking at is treating ConditionalExpression variable kinds as a special case in that case statement, and creating a new node converter to handle converting the conditional into a type. I'm still trying to determine how to create modify the variable reflection to have the correct type and be of the correct kind (the above screenshot should be marked as a function but it isn't) from the conditional. Does this sound like a reasonable approach?

[nicknisi]

Looking into this a bit more, I'm a bit confused on the best way to fix this. Adding a check for ts.SyntaxKind.ConditionalExpression in the switch statement in variable.ts does prevent the default value from being set to the entire ternary statement, but it gets complicated from there and I'm not sure how to correctly translate the node into declarations from there.

If the values on either side of the ternary are not functions, it seems like doing nothing works, and the correct type / union type is displayed.

If node.initializer.whenTrue and node.initializer.whenFalse are both method, then we need to determine if they have the same method signature, and if so, running just one through converter.convertNode outputs the correct method signature in the TypeDoc documents.

If whenTrue and whenFalse are both functions but they have different method signatures, then both of them can be displayed by running converter.convertNode on both of them.

But, if either one is a function when the other is not, I am not really sure how to correctly spit that information out, or what it should look like, given TypeDoc comments could have some @param tags that might map to just the function part of the expression.

Also, it looks like the same types of checking might need to occur when the node.initializer's kind is ts.SyntaxKind.BinaryExpression, where the checking is on the left and right properties, such as in

export const foo = someValue || someOtherValue;

[Gerrit0]

In 0.20, we use the type checker better, and will document the code in the op as: