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,11 +476,19 @@ func (p *Parser) makeQuestionIfOptional(parameter *ast.JSDocParameterTag) *ast.N
 	return questionToken
 }
 
-func findMatchingParameter(fun *ast.Node, tag *ast.JSDocParameterTag) (*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() {
-			return parameter.AsParameterDeclaration(), true
+func findMatchingParameter(fun *ast.Node, tag *ast.JSDocParameterTag, jsDoc *ast.Node) (*ast.ParameterDeclaration, bool) {
+	tagIndex := core.FindIndex(jsDoc.AsJSDoc().Tags.Nodes, func(n *ast.Node) bool {
+		return n.Kind == ast.KindJSDocParameterTag && n.AsJSDocParameterOrPropertyTag() == tag
+	})
+	for parameterIndex, parameter := range fun.Parameters() {
+		if parameter.Name().Kind == ast.KindIdentifier {
+			if tag.Name().Kind == ast.KindIdentifier && parameter.Name().Text() == tag.Name().Text() {
+				return parameter.AsParameterDeclaration(), true
+			}
+		} else {
+			if parameterIndex == tagIndex {
+				return parameter.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