I find most of these attempts to code-completion in JS to be annoying, like bad speech recognition, if the accuracy is poor, it becomes frustrating. Not to knock their attempt, but I find that if codeassist isn't like 98% accurate, it often becomes more work to step through all of the wrong entries and not find what I want, then to just type it out.
The closest I've seen to something that works well is IntelliJ IDEA 12, when working with ActionScript, Closure annotated JS (JsDoc'ed libraries), or by comparison, the Dart editor.
With IntelliJ 12, if you're looking at a library with enough JsDoc on functions, the type inferencing seems to be a lot more accurate. Find Usages, Go to Definition, code-assist, all seem to be more pleasurable to use.
I don't like Flash, but ActionScript3 in IntelliJ is as close to the Java/C#/et al experience you'll get with respect to accuracy of assist. Probably wouldn't hard to port this over to JSX or Typescript which have similar syntax.
If you're using completion to verify that a thing has the type you thought it has, then yes, Tern won't help you much. If you're using it to save keystrokes, it certainly will.
Slightly related, I'm working on a feature where it distinguishes wild guesses from probably correct information by showing a different icon in the completion list.
I love autocompletion (even when it is half working, like intellij when the inheritance marking annotations don't always follow through, my cleverly optimized jsdoc markup for backbone and co broke down when switching to idea12). It saves me so much time looking stuff up and APIs, and if it can indicate the number and name of arguments required, i usually don't have to use the docs anymore.
And M-./find usages is very useful too, even when it is not perfect.
I pledged, and hope you will get enough funds together.
Another way to go about it would be to mark the keywords that seem mistyped or auto-correct them. That would be less intrusive for people who don't want to select from drop downs.
The newest PyCharm uses an interesting dynamic approach. You can run your app in their debugger and enable collecting of type parameter info (at a significant performance loss, however).
So when you have a function like: def foobarize(f): return f.something *2; then it will know what types f might have when foobarize is called. Now when you go back into the editor, it can give you a hint about it.
Other than that, it uses some type hints from docstrings (you can tell it type foo is YourClass and it will complete based on that) and light type guessing.
I disagree, I believe TypeScript/VisualStudio provides a closer experience than AS/IntelliJ. The inference and refactoring work quite well. And they are in their infancy, generics are coming very soon.
Can you give an example of where AS/IJ fail and TS/VS succeeds? IntelliJ's started supporting TS recently and will likely improve. Their whole brand is multilanguage support and they support more languages than any other IDEA. For example, WebStorm 6 added TypeScript, CoffeeScript, and Dart.
The closest I've seen to something that works well is IntelliJ IDEA 12, when working with ActionScript, Closure annotated JS (JsDoc'ed libraries), or by comparison, the Dart editor.
With IntelliJ 12, if you're looking at a library with enough JsDoc on functions, the type inferencing seems to be a lot more accurate. Find Usages, Go to Definition, code-assist, all seem to be more pleasurable to use.
I don't like Flash, but ActionScript3 in IntelliJ is as close to the Java/C#/et al experience you'll get with respect to accuracy of assist. Probably wouldn't hard to port this over to JSX or Typescript which have similar syntax.