Repository: TypeScript
Issue: Order member intellisense by inheritance
Labels: Suggestion,Awaiting More Feedback

## Suggestion

I would like to see an optional way to allow the members of an object be displayed in the order in which they are inherited. In other words, the members should be listed from most specific to most general. Subclasses before superclasses. Perhaps a user could have this be their default intellisense behavior, or there could be a key-press to toggle this behavior.

## Use Cases

In several systems I've either worked in or looked at, I found myself thinking that it would be beneficial to order members by their order of inheritance. Consider this case: You have a `Node` in TypeScript or ESLint, and you narrow it to a certain kind of `Node`, for example, a `CallExpression`. You narrowed it to a `CallExpression` type because you want to do something specific to the `Node` only if it is the `CallExpression` type. You probably want to call a certain method or access a certain member which did not exist on `Node` but exists on `CallExpression`. As far as I'm concerned, **the most important members in any particular object are the ones most recently inherited**. If I only needed the information from `Node`, I would not have needed to narrow the type. Hence, I would like to see members from subclasses prioritized over members from superclasses.

Often times when working in a system where objects have tons of methods and properties, I find myself putting the `ts.CallExpression` type somewhere so I can go-to-definition and look for myself what the "latest" methods are for a narrowed object. Here's a little reenactment of what I've actually done during development many times:

![intellisense video](https://user-images.githubusercontent.com/15217173/76494967-f0737780-6403-11ea-9e80-ecd587711075.gif)
###### This example actually uses ts-node, which, as a side effect of being a wrapper for TS, wraps properties as methods. E.g. `returnType: Type` becomes `getReturnType(): Type` in ts-node. It also aggregates all useful operations you could perform on/with an object, e.g. it allows you to do things like call `getType()` directly on any `Node`, which under the hood delegates to the proper TS typechecker API.



<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->

## Examples

How it could look:

![image](https://user-images.githubusercontent.com/15217173/76495973-0124ed00-6406-11ea-90b2-d00a1ae8a8b3.png)
###### In the above image, `B.y` comes before `A.x` because `B` is the lowest subclass and `A` is the superclass.

Members inherited from the same class or same type would be sorted alphabetically.

It is possible for a particular type to inherit members from multiple types along the same inheritance level via intersection types. In this case, members of each individual type would be grouped together, with subsequent intersected types taking priority. E.g. `A & B` would display all the members of `B` as a group, followed by all the members of `A` as a group.

![image](https://user-images.githubusercontent.com/15217173/76498371-c2456600-640a-11ea-9f03-423a27e2ee3a.png)

Groups could optionally be separated by extra spacing or perhaps a horizontal bar:

![image](https://user-images.githubusercontent.com/15217173/76498750-7b0ba500-640b-11ea-9318-18a8c6c1c9b8.png)

Keep in mind that types which have been reconstructed out of intersected types would not be affected:

![image](https://user-images.githubusercontent.com/15217173/76498971-e2c1f000-640b-11ea-919d-7d49f59125be.png)

Members from subclasses or subsequent types in an intersection which intersect with superclasses or prior types in an intersection should be listed with the superclass or prior type group.

![image](https://user-images.githubusercontent.com/15217173/76501914-1e12ed80-6411-11ea-9119-a9c7941ad971.png)


There could also optionally be a keybind for VSCode which toggles this setting, so you could switch between alphabetical and inheritance-based ordering on the fly.

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).