Method and Function overloads

[hookyns]

Method and Function overloads

[Hookyns]

@carloszimm
Implemented in [email protected] and [email protected].

[Hookyns]

it only prints the first signature (overload) of the function

Hello @carloszimm,
I have to change the Type.function: FunctionInfo to something like Type.getSignatures(): ReadonlyArray<FunctionInfo>.

FYI @avin-kavish

[Hookyns]

type.getConstructors() returns list with constructor or its overloads.
type.getMethods() returns list of methods with their overloads. Each overload is treated the same as method itself. Overload represents callable method. You can detect overloaded methods by grouping methods by name.

StackBlitz demo.

export class SomeClass {
  constructor();
  constructor(a?: boolean);
  constructor(b?: string);
  constructor(a: boolean, b?: string);
  constructor(aOrB?: boolean | string, b?: string) {}

  someMethod(a?: boolean);
  someMethod(b?: string);
  someMethod(aOrB?: boolean | string) {}

  someOtherMethod() {}
}

While writing the demo I figured out that method overloads does not work and we don't even have the unit test for that.
I've prepared the fix, I'll publish that in the evening.

This is the output from that demo running with fixed version:

Constructors:
┌─────────┬───────────────┬──────────────┐
│ (index) │       0       │      1       │
├─────────┼───────────────┼──────────────┤
│    0    │               │              │
│    1    │ 'a?: Boolean' │              │
│    2    │ 'b?: String'  │              │
│    3    │ 'a: Boolean'  │ 'b?: String' │
└─────────┴───────────────┴──────────────┘
Methods:
┌─────────┬───────────────────┬───────────────────┐
│ (index) │         0         │         1         │
├─────────┼───────────────────┼───────────────────┤
│    0    │   'someMethod'    │ [ 'a?: Boolean' ] │
│    1    │   'someMethod'    │ [ 'b?: String' ]  │
│    2    │   'someMethod'    │   [ 'aOrB?: ' ]   │
│    3    │ 'someOtherMethod' │        []         │
└─────────┴───────────────────┴───────────────────┘

[Hookyns]

• yeah, thats wrong. Implementation shoud not be visible. Ctors are ok, methods are not.
• I just simply ouput type name. That union is Container type, it does not have name. There is Type.isUnion() and Type.getTypes(). The getTypes returns array of unioned types, you have to handle it.

[Hookyns]

Still a bug for me until I fix that issue with listed implementation signature which. I think I'll be able to fix it today.

[Hookyns]

I just published [email protected] and [email protected] with fixed method overloads and added function overloads.

[Hookyns]

@all-contributors please add @carloszimm for ideas and bug report

[carloszimm]

Got it.
Thanks, @Hookyns!
Looking forward to your fix :)

[carloszimm]

@Hookyns
I tested and it's working as expected (following your output posted above). I just have some questions.

1 - While the output for the "someMethod" listed the definitions as well as the implementation, the output for the constructor only included the definitions of it. Is that the expected output?
2 - The last output of "someMethod" didn't show the (union) type for the parameter. Is that the expected output? If so, should I invoke a different method for union types for example?

[carloszimm]

Gotcha (:

[carloszimm]

• yeah, thats wrong. Implementation shoud not be visible. Ctors are ok, methods are not.

@Hookyns before closing this issue, should the above point still be flagged as a bug or it was a matter of modifying the code (solution) to detect those specific cases (methods)?

[carloszimm]

Important to note that it's an overload matter. If there wasn't overload, the output of the implementation signature would be ok :)

[Hookyns]

Sure 🙂

[carloszimm]

Hello again @Hookyns

So, I'm facing trouble when it comes to reflect on functions + overloads. To be more specific, I'm trying to reflect on functions exported by a library, and many of them have overloads. Your above examples reflect on classes which is more straight forward but the functions (signatures + implementation) I'm working on are all exported separately using ES module (all located at the same file). I followed the code available in #48 but it only prints the first signature (overload) of the function and I have no idea how to modify it adequately to handle that case. For instance, supposing I'm trying to reflecting on the following function (filter) of the RxJS library (one of my fav libs); I can only get the first signature listed in that file using the code of #48. Any ideas on how to properly handle this case or it is something still to be implemented/enhanced in the tst-reflect lib? I thought about trying to gather those signatures in some way/object to then get the overloads' infos but I have no clue how to proceed.

Thanks!

[allcontributors]

@Hookyns

I've put up a pull request to add @carloszimm! 🎉