When we decided to make use of the same index format as JDT, we expected to also retain similar usage. JS usage of the index falls pretty far outside of that by effectively serializing properties/functions/events/event properties using JSON. This can lead to very large "keys" and can make it nearly impossible to do easy queries using patterns for particular attributes.
Currently we store type, function, property, event, require. The first four are simply the declarations. The last is a very specific instance of recording references to the 'require' function/method.
JDT typically stores declarations with more details, but also stores references to types/fields/methods; and records references to supertypes/interfaces separate from the type declaration. Additionally, declaration keys are typically simple and compact.
Obviously we store much more information and we expect to fully serialize the metadata from the index, whereas JDT uses the index for matching and then opens the defining document/file and parses to reconstruct when more details are necessary. Additionally we store type inferencing data in the index where JDT doesn't need to (it records type info in relavent index categories, but doesn't need to for fields/vars/methods as it can always easily look it up).
The open question is whether we can do the same - and to do so what sort of information will we need to record in the index and what can we lookup on-demand?