fix(1196): extend parameter matching with index fallback when name matching fails

Author: a-tarasyuk

internal/parser/reparser.go

@@ -171,7 +171,11 @@ func (p *Parser) reparseJSDocSignature(jsSignature *ast.Node, fun *ast.Node, jsD
 }
 
 func (p *Parser) reparseJSDocTypeLiteral(t *ast.TypeNode, host *ast.Node) *ast.Node {
-	if t != nil && t.Kind == ast.KindJSDocTypeLiteral {
+	if t == nil {
+		return nil
+	}
+	if t.Kind == ast.KindJSDocTypeLiteral {
+		isArrayType := t.AsJSDocTypeLiteral().IsArrayType
 		properties := p.nodeSlicePool.NewSlice(0)
 		for _, prop := range t.AsJSDocTypeLiteral().JSDocPropertyTags {
 			jsprop := prop.AsJSDocParameterOrPropertyTag()
@@ -180,7 +184,9 @@ func (p *Parser) reparseJSDocTypeLiteral(t *ast.TypeNode, host *ast.Node) *ast.N
 				name = name.AsQualifiedName().Right
 			}
 			property := p.factory.NewPropertySignatureDeclaration(nil, name, p.makeQuestionIfOptional(jsprop), nil, nil)
-			property.AsPropertySignatureDeclaration().Type = p.reparseJSDocTypeLiteral(jsprop.TypeExpression, property)
+			if jsprop.TypeExpression != nil {
+				property.AsPropertySignatureDeclaration().Type = p.reparseJSDocTypeLiteral(jsprop.TypeExpression.Type(), property)
+			}
 			property.Loc = prop.Loc
 			property.Flags = p.contextFlags | ast.NodeFlagsReparsed
 			properties = append(properties, property)
@@ -189,6 +195,11 @@ func (p *Parser) reparseJSDocTypeLiteral(t *ast.TypeNode, host *ast.Node) *ast.N
 		t = p.factory.NewTypeLiteralNode(p.newNodeList(loc, properties))
 		t.Loc = loc
 		t.Flags = p.contextFlags | ast.NodeFlagsReparsed
+		if isArrayType {
+			t = p.factory.NewArrayTypeNode(t)
+			t.Flags = p.contextFlags | ast.NodeFlagsReparsed
+			t.Loc = loc
+		}
 	}
 	return t
 }
@@ -327,13 +338,17 @@ func (p *Parser) reparseHosted(tag *ast.Node, parent *ast.Node, jsDoc *ast.Node)
 		}
 	case ast.KindJSDocParameterTag:
 		if fun, ok := getFunctionLikeHost(parent); ok {
-			jsparam := tag.AsJSDocParameterOrPropertyTag()
-			if param, ok := findMatchingParameter(fun, jsparam); ok {
+			parameterTag := tag.AsJSDocParameterOrPropertyTag()
+			if param, ok := findMatchingParameter(fun, parameterTag, jsDoc); ok {
 				if param.Type == nil {
-					param.Type = setHost(jsparam.TypeExpression, param.AsNode())
+					paramType := setHost(parameterTag.TypeExpression, param.AsNode())
+					if parameterTag.IsNameFirst && parameterTag.TypeExpression != nil && parameterTag.TypeExpression.Type().Kind == ast.KindJSDocTypeLiteral {
+						paramType = p.reparseJSDocTypeLiteral(parameterTag.TypeExpression.Type(), param.AsNode())
+					}
+					param.AsParameterDeclaration().Type = paramType
 				}
 				if param.QuestionToken == nil && param.Initializer == nil {
-					if question := p.makeQuestionIfOptional(jsparam); question != nil {
+					if question := p.makeQuestionIfOptional(parameterTag); question != nil {
 						param.QuestionToken = question
 					}
 				}
@@ -461,13 +476,21 @@ func (p *Parser) makeQuestionIfOptional(parameter *ast.JSDocParameterTag) *ast.N
 	return questionToken
 }
 
-func findMatchingParameter(fun *ast.Node, tag *ast.JSDocParameterTag) (*ast.ParameterDeclaration, bool) {
+func findMatchingParameter(fun *ast.Node, tag *ast.JSDocParameterTag, jsDoc *ast.Node) (*ast.ParameterDeclaration, bool) {
 	for _, parameter := range fun.Parameters() {
-		if parameter.Name().Kind == ast.KindIdentifier && tag.Name().Kind == ast.KindIdentifier &&
-			parameter.Name().Text() == tag.Name().Text() {
+		if parameter.Name().Kind == ast.KindIdentifier && tag.Name().Kind == ast.KindIdentifier && parameter.Name().Text() == tag.Name().Text() {
 			return parameter.AsParameterDeclaration(), true
 		}
 	}
+
+	index := core.FindIndex(jsDoc.AsJSDoc().Tags.Nodes, func(n *ast.Node) bool {
+		return n.Kind == ast.KindJSDocParameterTag && n.AsJSDocParameterOrPropertyTag() == tag
+	})
+
+	if index < len(fun.Parameters()) {
+		return fun.Parameters()[index].AsParameterDeclaration(), true
+	}
+
 	return nil, false
 }
 

testdata/baselines/reference/conformance/jsdocParseAwait.types

@@ -14,10 +14,10 @@ const a = 1;
 /** @type {T} */
 const b = {
 >b : T
->{    await: false,} : { await: boolean; }
+>{    await: false,} : { await: false; }
 
     await: false,
->await : boolean
+>await : false
 >false : false
 
 };

testdata/baselines/reference/submodule/compiler/checkJsdocTypeTagOnExportAssignment8.types

@@ -11,14 +11,14 @@
 
 /** @type {Foo} */
 export default {
->{    a: 'a',    b: 'b'} : { a: string; b: string; }
+>{    a: 'a',    b: 'b'} : { a: string; b: "b"; }
 
     a: 'a',
 >a : string
 >'a' : "a"
 
     b: 'b'
->b : string
+>b : "b"
 >'b' : "b"
 }
 

testdata/baselines/reference/submodule/compiler/declarationEmitClassSetAccessorParamNameInJs2.types

@@ -10,6 +10,6 @@ export class Foo {
      * @param {{ prop: string }} baz Baz.
      */
     set bar({}) {}
->bar : any
+>bar : { prop: string; }
 }
 

testdata/baselines/reference/submodule/compiler/declarationEmitClassSetAccessorParamNameInJs3.types

@@ -10,7 +10,7 @@ export class Foo {
      * @param {{ prop: string | undefined }} baz Baz.
      */
     set bar({ prop = 'foo' }) {}
->bar : any
+>bar : { prop: string; }
 >prop : string
 >'foo' : "foo"
 }

testdata/baselines/reference/submodule/compiler/jsDeclarationEmitDoesNotRenameImport.types

@@ -40,19 +40,19 @@ class X extends Test {
 >super : typeof Test
 
         if (options.test) {
->options.test : any
+>options.test : typeof import("./Test.js").default | undefined
 >options : Options
->test : any
+>test : typeof import("./Test.js").default | undefined
 
             this.test = new options.test();
->this.test = new options.test() : any
+>this.test = new options.test() : import("./Test.js").default
 >this.test : any
 >this : this
 >test : any
->new options.test() : any
->options.test : any
+>new options.test() : import("./Test.js").default
+>options.test : typeof import("./Test.js").default
 >options : Options
->test : any
+>test : typeof import("./Test.js").default
         }
     }
 }

testdata/baselines/reference/submodule/compiler/jsdocParamTagInvalid.types

@@ -3,6 +3,6 @@
 === /a.js ===
 /** @param {string} colour */
 function f(color) {}
->f : (color: any) => void
->color : any
+>f : (color: string) => void
+>color : string
 

testdata/baselines/reference/submodule/compiler/jsdocPropertyTagInvalid.errors.txt

@@ -0,0 +1,18 @@
+/a.js(3,15): error TS2552: Cannot find name 'sting'. Did you mean 'string'?
+
+
+==== /a.js (1 errors) ====
+    /**
+     * @typedef MyType
+     * @property {sting} [x]
+                  ~~~~~
+!!! error TS2552: Cannot find name 'sting'. Did you mean 'string'?
+     */
+    
+    /** @param {MyType} p  */
+    export function f(p) { }
+    
+==== /b.js (0 errors) ====
+    import { f } from "./a.js"
+    f({ x: 42 })
+    

testdata/baselines/reference/submodule/compiler/strictOptionalProperties3.errors.txt

@@ -1,16 +1,23 @@
+a.js(7,7): error TS2375: Type '{ value: undefined; }' is not assignable to type 'A' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties.
+  Types of property 'value' are incompatible.
+    Type 'undefined' is not assignable to type 'number'.
 a.js(14,7): error TS2375: Type '{ value: undefined; }' is not assignable to type '{ value?: number; }' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties.
   Types of property 'value' are incompatible.
     Type 'undefined' is not assignable to type 'number'.
 
 
-==== a.js (1 errors) ====
+==== a.js (2 errors) ====
     /**
      * @typedef {object} A
      * @property {number} [value]
      */
 
     /** @type {A} */
     const a = { value: undefined }; // error
+          ~
+!!! error TS2375: Type '{ value: undefined; }' is not assignable to type 'A' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties.
+!!! error TS2375:   Types of property 'value' are incompatible.
+!!! error TS2375:     Type 'undefined' is not assignable to type 'number'.
 
     /**
      * @typedef {{ value?: number }} B

testdata/baselines/reference/submodule/compiler/strictOptionalProperties4.types

@@ -12,17 +12,17 @@ const x = /** @type {Foo} */ ({});
 >{} : {}
 
 x.foo; // number | undefined
->x.foo : any
+>x.foo : number | undefined
 >x : Foo
->foo : any
+>foo : number | undefined
 
 const y = /** @type {Required<Foo>} */ ({});
 >y : Required<Foo>
 >({}) : Required<Foo>
 >{} : {}
 
 y.foo; // number
->y.foo : any
+>y.foo : number
 >y : Required<Foo>
->foo : any
+>foo : number
 

testdata/baselines/reference/submodule/conformance/checkJsdocSatisfiesTag1.types

@@ -44,9 +44,9 @@ const t3 = /** @satisfies {T1} */ ({});
 /** @type {T2} */
 const t4 = /** @satisfies {T2} */ ({ a: "a" });
 >t4 : T2
->({ a: "a" }) : { a: string; }
->{ a: "a" } : { a: string; }
->a : string
+>({ a: "a" }) : { a: "a"; }
+>{ a: "a" } : { a: "a"; }
+>a : "a"
 >"a" : "a"
 
 /** @type {(m: string) => string} */

testdata/baselines/reference/submodule/conformance/checkJsdocTypedefInParamTag1.types

@@ -16,9 +16,9 @@ function foo(opts) {
 >opts : Opts
 
     opts.x;
->opts.x : any
+>opts.x : string
 >opts : Opts
->x : any
+>x : string
 }
 
 foo({x: 'abc'});
@@ -40,9 +40,9 @@ function foo1(opts) {
 >opts : AnotherOpts
 
     opts.anotherX;
->opts.anotherX : any
+>opts.anotherX : string
 >opts : AnotherOpts
->anotherX : any
+>anotherX : string
 }
 
 foo1({anotherX: "world"});
@@ -66,9 +66,9 @@ function foo2(opts) {
 >opts : Opts1
 
     opts.x;
->opts.x : any
+>opts.x : string
 >opts : Opts1
->x : any
+>x : string
 }
 foo2({x: 'abc'});
 >foo2({x: 'abc'}) : void

testdata/baselines/reference/submodule/conformance/destructuringParameterDeclaration9(strict=false).symbols

@@ -9,7 +9,7 @@ export function prepareConfig({
 >prepareConfig : Symbol(prepareConfig, Decl(index.js, 0, 0))
 
     additionalFiles: {
->additionalFiles : Symbol(additionalFiles)
+>additionalFiles : Symbol(additionalFiles, Decl(index.js, 2, 3))
 
         json = []
 >json : Symbol(json, Decl(index.js, 5, 22))
@@ -60,7 +60,7 @@ export const prepareConfigWithContextualSignature = ({
  */
 function f1({ a: { json = [] } = {} } = {}) { return json }
 >f1 : Symbol(f1, Decl(index.js, 29, 1))
->a : Symbol(a)
+>a : Symbol(a, Decl(index.js, 34, 12))
 >json : Symbol(json, Decl(index.js, 36, 18))
 >json : Symbol(json, Decl(index.js, 36, 18))
 

testdata/baselines/reference/submodule/conformance/destructuringParameterDeclaration9(strict=false).symbols.diff

@@ -6,13 +6,13 @@
  * @param {Partial<Record<'json' | 'jsonc' | 'json5', string[]>>} [config.additionalFiles]
  */
 export function prepareConfig({
->prepareConfig : ({ additionalFiles: { json } }?: { additionalFiles?: { json?: any[]; }; }) => void
+>prepareConfig : ({ additionalFiles: { json } }?: { additionalFiles?: Partial<Record<"json" | "json5" | "jsonc", string[]>>; }) => void
 
     additionalFiles: {
 >additionalFiles : any
 
         json = []
->json : any[]
+>json : string[]
 >[] : undefined[]
 
     } = {}
@@ -22,7 +22,7 @@ export function prepareConfig({
 >{} : {}
 
     json // string[]
->json : any[]
+>json : string[]
 }
 
 export function prepareConfigWithoutAnnotation({
@@ -75,22 +75,22 @@ export const prepareConfigWithContextualSignature = ({
  * @param {{ a?: { json?: string[] }}} [config]
  */
 function f1({ a: { json = [] } = {} } = {}) { return json }
->f1 : ({ a: { json } }?: { a?: { json?: any[]; }; }) => any[]
+>f1 : ({ a: { json } }?: { a?: { json?: string[]; }; }) => string[]
 >a : any
->json : any[]
+>json : string[]
 >[] : undefined[]
 >{} : {}
 >{} : {}
->json : any[]
+>json : string[]
 
 /**
  * @param {[[string[]?]?]} [x]
  */
 function f2([[json = []] = []] = []) { return json }
->f2 : ([[json]]?: [[any[]?]?]) => any[]
->json : any[]
+>f2 : ([[json]]?: [[string[]?]?]) => string[]
+>json : string[]
 >[] : undefined[]
 >[] : []
 >[] : []
->json : any[]
+>json : string[]
 

testdata/baselines/reference/submodule/conformance/destructuringParameterDeclaration9(strict=false).types

@@ -9,7 +9,7 @@ export function prepareConfig({
 >prepareConfig : Symbol(prepareConfig, Decl(index.js, 0, 0))
 
     additionalFiles: {
->additionalFiles : Symbol(additionalFiles)
+>additionalFiles : Symbol(additionalFiles, Decl(index.js, 2, 3))
 
         json = []
 >json : Symbol(json, Decl(index.js, 5, 22))
@@ -60,7 +60,7 @@ export const prepareConfigWithContextualSignature = ({
  */
 function f1({ a: { json = [] } = {} } = {}) { return json }
 >f1 : Symbol(f1, Decl(index.js, 29, 1))
->a : Symbol(a)
+>a : Symbol(a, Decl(index.js, 34, 12))
 >json : Symbol(json, Decl(index.js, 36, 18))
 >json : Symbol(json, Decl(index.js, 36, 18))