* Parameters infer from body usage and call sites
* Function expressions infer from variable decl usages
If the function expression is the initialiser of a variable declaration.
* Update isApplicableFunctionForInference too
* Update baseline
* module.exports aliases have correct flags
They are marked both as (1) alias and (2) assignment declaration. This
fixes alias resolution in cases where multiple module.exports
assignments exist, but differ in whether they are aliases or not:
```js
function f() { }
module.exports = f
module.exports = 23
```
Previously, this construct would fail to resolve the alias `f` because
the `export=` symbol would be marked as Alias | Value but not
Assignment. This change just adds Assignment so that the assignment
declaration alias-following rules apply: you should always follow the
alias, regardless of other flags.
Also, isAliasSymbolDeclaration needed to be tightened up. Previously, I
missed the condition that `module.exports =` aliases required an
EntityNameDeclaration on right-hand-side, just like `export default` and
`export =` aliases.
* Address PR comments
1. Rename test to be more accurate.
2. Always mark module.exports assignments with SymbolFlags.Assignment.
* infer from usage's unification uses multiple passes
Previously, the unification step of infer-from-usage codefix would stop
as soon an answer was found. Now it continues if the result is
*incomplete*, with the idea that later passes may provide a better
inference.
Currently, an *incomplete* inference is
1. The type any.
2. The empty object type `{}` or a union or intersection that contains
`{}`.
In the checker, any takes priority over other types since it basically
shuts down type checking. For type inference, however, any is one of the least
useful inferences.
`{}` is not a good inference for a similar reason; as a parameter
inference, it doesn't tell the caller much about what is expected, and
it doesn't allow the function author to use an object as expected. But
currently it's inferred whenever there's an initialisation with the
value `{}`. With this change, subsequent property assignments to the
same parameter will replace the `{}` with a specific anonymous type. For
example:
```js
function C(config) {
if (config === undefined) config = {};
this.x = config.x;
this.y = config.y;
this.z = config.z;
}
```
* Unify all passes of inference from usage
In the previous commit, I changed inference from usage to continue
inference if a the result was *incomplete*. This commit now runs all 4
inference passes and combines them in a unification step. Currently the
unification step is simple, it:
1. Gathers all inferences in a list.
2. Makes properties of anonymous types optional if there is an empty
object in the inference list.
3. Removes *vacuous* inferences.
4. Combines the type in a union.
An inference is *vacuous* if it:
1. Is any or void, when a non-any, non-void type is also inferred.
2. Is the empty object type, when an object type that is not empty is
also inferred.
3. Is an anonymous type, when a non-nullable, non-any, non-void,
non-anonymous type is also inferred.
I think I might eventually want a concept of priorities, like the
compiler's type parameter inference, but I don't have enough examples to
be sure yet.
Eventually, unification should have an additional step that examines the
whole inference list to see if its contents are collectively
meaningless. A good example is `null | undefined`, which is not useful.
* Remove isNumberOrString
* Unify anonymous types
@andy-ms pointed out that my empty object code was a special case of
merging all anonymous types from an inference and making properties
optional that are not in all the anonymous type. So I did that instead.
* Use getTypeOfSymbolAtLocation instead of Symbol.type!
* Unify parameter call-site inferences too
Because they still have a separate code path, they didn't use the new
unification code.
Also some cleanup from PR comments.
* Add object type unification test
Also remove dead code.
* Only use fallback if no inferences were found
Instead of relying on the unification code to remove the fallback.
For parameters, the infer-from-usage codefix uses a substantially
different codepath that previously only looked at call site uses. When
this resulted in no inferences, or bad inferences, for a single
parameter, the codefix would just use any. Only if no usages of a
function were found would the codefix use the body-inference
code.
This commit makes parameter inference fall back to body-inference code
for individual parameters when there is no inference or inference to
any.
* infer from usage JSDoc:Don't emit nested comments
Previously, the trivia on a parameter name would show up inside the
emitted JSDoc comment. If the trivia contained a C-style comment, the
emitted JSDoc comment would be invalid. For example:
```js
function call(callback /*oh no*/) {
return callback(this)
}
```
Emitted this comment:
```js
/**
* @param {(arg0: any) => void} callback /*oh no*/
*/
```
* Remove misleading comment used for debugging.
* Correct indentation, using correct (I hope) indentation code
Note that part of the code, in formatting.ts, is cloned but should be
extracted to a function instead.
* Remove some possibly-superfluous code
But I see 4 failures with whitespace, so perhaps not.
* Restrict indentation change to avoid breaking baselines
The indentation code is very complex so I'm just going to avoid breaking
our single-line tests for now, plus add a simple jsdoc test to show that
multiline jsdoc indentation isn't destroyed in the common case.
* Switched over to construction for @return/@type
Still doesn't merge correctly though
* Add @return tags to emitter
* Merge multiple jsdocs
(not for @param yet)
* Merge multiple jsdoc for parameters too
* Emit more jsdoc tags
Not all of them; I got cold feet since I'll have to write tests for
them. I'll do that tomorrow.
* Many fixes to JSDoc emit
And single tests (at least) for all tags
* Cleanup in textChanges.ts
* Cleanup in formatting.ts
(Plus a little more in textChanges.ts)
* Cleanup in inferFromUsage.ts
* Fix minor omissions
* Separate merged top-level JSDoc comments with \n
instead of space.
* Don't delete intrusive non-jsdoc comments
* Cleanup from PR comments
1. Refactor emit code into smaller functions.
2. Preceding-whitespace utility is slightly easier to use.
3. Better casts and types in inferFromUsage make it easier to read.
* Fix bogus newline
* Use @andy-ms' cleanup annotateJSDocParameters
1. Sort is now stable in node 11, which exposed a lack in the sorting of
nested ranges. Ranges now sort based on last ending if the start
positions are the same. This means nested ranges sort the
containing range first, even if a range contains another range that
starts at the same position.
2. Symbol has a new member description which can't be accessed through
the prototype. In addition, Array now has flat and flatMap, which I
excluded to keep baselines the same between Node 6-11.
* Add new special assignment kinds for recognizing Object.defineProperty calls
* Add support for prototype assignments, fix nits
* Fix code review comments
* Add test documenting behavior in a few more odd scenarios
* Unify JSX Call Checking Codepaths
* Add tests for fixed issues
* Fix lint, move all error checking into the only-run-once resolveSignature call
* Remove unused (unreachable?) code path
* Consolidate a little more duplicated logic into signature checking
* Fix#19775 a bit more
* Cosmetic changes from CR
* Add helpers that understand constructor functions
* getEffectiveConstructSignatures gets construct signatures from type, and
call signatures from constructor functions if there are no construct
signatures.
* getEffectiveConstructSignatureReturnType gets the "JS Class type" for
constructor functions, and the return type of signatures for all other
declarations.
This is a first step toward making constructor functions have construct
signatures instead of call signatures, which will also contribute to
fixing instantiation of generic constructor functions, which is basically
broken right now.
Note that the baselines *improve* but, because of the previously
mentioned generic problem, are still not correct. Construct signatures
for constructor functions and generic constructor functions turns out to
be an intertwined problem.
* Correct correct originalBaseType
And, for now, return anyType for generic constructor functions used as
base types. Don't give an incorrect error based on the function's return
type, which is usually void.
* Add error examples to tests
* Add construct signatures instead of getEffective* functions
* Fix typo in baseline
* Remove pesky newline
I thought I got rid of it!
* Test of constructor tag on object literal method
It doesn't work, and shouldn't in the future, because it's a runtime
error.
* noImplicitAny as suggestion
Note that not all noImplicitAny errors turn into suggestions. In
particular,
1. reportErrorsFromWidening does not, because it doesn't log an error
that infer-from-usage fixes, and fixing it would require
otherwise-unnecessary code.
2. auto types do not have implicit any suggestions, because that would
require running control flow in noImplicitAny mode.
* Rename reportImplicitAny+forbid it for non-checkJS
In JS, you only get implicit any errors/suggestions with checkJS or
ts-check turned on.
* Update baselines
* Use isCheckJsEnabledForFile
* Remove noImplicitAny parameter since it's in scope already
* Now adding @type to variable declarations, at least
Probably everything else, but not as well.
* Improve @param output and add test
It's still bad, but at least it's not wrong.
* Add some js/inferFromUsage tests and fixes
Also, remove redundant is(Set|Get)Accessor functions.
* Fix @typedef refactor
* Emit JSDoc optional parameters
By surrounding the parameter name with brackets. It is super, super ugly
right now.
* Get rest of existing tests working
* Correct location of comments
* Handle @param blocks
1. Format multiple params nicely in a single-multiline block.
2. Generate only params that haven't already been documented. Existing
documentation is not touched.
* Re-add isGet/SetAccessor -- it is part of the API
* Move isSet/GetAccessor back to the original location
* Oh no I missed a newline and a space
* Switch to an object type
* A lot of cleanup
More to come, though. annotate is only called in
annotateVariableDeclaration where we don't know whether we're in JS or
not.
* Move and delegate to annotateJSDocParameters
* Address PR comments
* Lint: newline problems!!!!
* Switch another call to getNonformattedText
* Update baseline missed after merge
