fix(64058): fix reparse jsdoc @extends type arguments for call expressions

Author: a-tarasyuk

tsc/internal/ast/utilities.go

@@ -1645,16 +1645,6 @@ func IsDottedName(node *Node) bool {
 	return false
 }
 
-func HasSamePropertyAccessName(node1, node2 *Node) bool {
-	if node1.Kind == KindIdentifier && node2.Kind == KindIdentifier {
-		return node1.Text() == node2.Text()
-	} else if node1.Kind == KindPropertyAccessExpression && node2.Kind == KindPropertyAccessExpression {
-		return node1.AsPropertyAccessExpression().Name().Text() == node2.AsPropertyAccessExpression().Name().Text() &&
-			HasSamePropertyAccessName(node1.Expression(), node2.Expression())
-	}
-	return false
-}
-
 func IsAmbientModule(node *Node) bool {
 	return IsModuleDeclaration(node) && (node.AsModuleDeclaration().Name().Kind == KindStringLiteral || IsGlobalScopeAugmentation(node))
 }

tsc/internal/parser/parser_test.go

@@ -308,6 +308,55 @@ function foo(options) {}`
 	assert.Equal(t, scanner.GetTokenPosOfNode(typeNode, file, false /*includeJSDoc*/), strings.Index(sourceText, "{{")+1)
 }
 
+func TestJSDocAugmentsTypeArgumentsReparse(t *testing.T) {
+	t.Parallel()
+	sourceText := `/** @template T */
+class A {
+  static extend() {
+    return this;
+  }
+}
+
+/** @extends {A<string>} */
+class B extends A.extend() {}`
+	opts := ast.SourceFileParseOptions{
+		FileName: "/index.js",
+		Path:     "/index.js",
+	}
+
+	file := parser.ParseSourceFile(opts, sourceText, core.ScriptKindJS)
+	statements := file.Statements.Nodes
+	assert.Equal(t, len(statements), 2)
+
+	classB := statements[1]
+	assert.Assert(t, ast.IsClassDeclaration(classB))
+
+	baseType := ast.GetClassExtendsHeritageElement(classB)
+	assert.Assert(t, baseType != nil)
+	assert.Assert(t, ast.IsCallExpression(baseType.Expression()))
+
+	typeArguments := baseType.TypeArguments()
+	assert.Equal(t, len(typeArguments), 1)
+
+	typeArgument := typeArguments[0]
+	assert.Equal(t, typeArgument.Kind, ast.KindStringKeyword)
+	assert.Assert(t, typeArgument.Flags&ast.NodeFlagsReparsed != 0)
+
+	jsDocs := classB.JSDoc(file)
+	assert.Equal(t, len(jsDocs), 1)
+
+	tags := jsDocs[0].AsJSDoc().Tags
+	assert.Assert(t, tags != nil)
+	assert.Equal(t, len(tags.Nodes), 1)
+
+	tag := tags.Nodes[0]
+	assert.Assert(t, ast.IsJSDocAugmentsTag(tag))
+
+	sourceTypeArguments := tag.ClassName().TypeArguments()
+	assert.Equal(t, len(sourceTypeArguments), 1)
+	assert.Equal(t, ast.GetReparsedNodeForNode(sourceTypeArguments[0]), typeArgument)
+}
+
 func TestSourceFilePositionMapWithNonASCIIStringLiteral(t *testing.T) {
 	t.Parallel()
 	sourceText := `const x = "─";

tsc/internal/parser/reparser.go

@@ -597,15 +597,13 @@ func (p *Parser) reparseHosted(tag *ast.Node, parent *ast.Node, jsDoc *ast.Node)
 			}); extendsClause != nil && len(extendsClause.AsHeritageClause().Types.Nodes) == 1 {
 				target := extendsClause.AsHeritageClause().Types.Nodes[0].AsExpressionWithTypeArguments()
 				source := tag.ClassName().AsExpressionWithTypeArguments()
-				if ast.HasSamePropertyAccessName(target.Expression, source.Expression) {
-					if target.TypeArguments == nil && source.TypeArguments != nil {
-						newArguments := p.nodeSliceArena.NewSlice(len(source.TypeArguments.Nodes))
-						for i, arg := range source.TypeArguments.Nodes {
-							newArguments[i] = p.addDeepCloneReparse(arg)
-						}
-						target.TypeArguments = p.newNodeList(source.TypeArguments.Loc, newArguments)
-						p.finishMutatedNode(target.AsNode())
+				if target.TypeArguments == nil && source.TypeArguments != nil {
+					newArguments := p.nodeSliceArena.NewSlice(len(source.TypeArguments.Nodes))
+					for i, arg := range source.TypeArguments.Nodes {
+						newArguments[i] = p.addDeepCloneReparse(arg)
 					}
+					target.TypeArguments = p.newNodeList(source.TypeArguments.Loc, newArguments)
+					p.finishMutatedNode(target.AsNode())
 				}
 			}
 		}

tsc/testdata/baselines/reference/conformance/extendsTag7.symbols

@@ -0,0 +1,37 @@
+//// [tests/cases/conformance/jsdoc/extendsTag7.ts] ////
+
+=== a.js ===
+/** @template T */
+class A {
+>A : Symbol(A, Decl(a.js, 0, 0))
+
+    /** @returns {T} */
+    get value() {
+>value : Symbol(A.value, Decl(a.js, 1, 9))
+
+        throw new Error();
+>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+    }
+
+    /** @returns {typeof A} */
+    static extend() {
+>extend : Symbol(A.extend, Decl(a.js, 5, 5))
+
+        return this;
+>this : Symbol(A, Decl(a.js, 0, 0))
+    }
+}
+
+/** @extends {A<string>} */
+class B extends A.extend() {}
+>B : Symbol(B, Decl(a.js, 11, 1))
+>A.extend : Symbol(A.extend, Decl(a.js, 5, 5))
+>A : Symbol(A, Decl(a.js, 0, 0))
+>extend : Symbol(A.extend, Decl(a.js, 5, 5))
+
+const value = new B().value;
+>value : Symbol(value, Decl(a.js, 16, 5))
+>new B().value : Symbol(A.value, Decl(a.js, 1, 9))
+>B : Symbol(B, Decl(a.js, 11, 1))
+>value : Symbol(A.value, Decl(a.js, 1, 9))
+

tsc/testdata/baselines/reference/conformance/extendsTag7.types

@@ -0,0 +1,40 @@
+//// [tests/cases/conformance/jsdoc/extendsTag7.ts] ////
+
+=== a.js ===
+/** @template T */
+class A {
+>A : A<T>
+
+    /** @returns {T} */
+    get value() {
+>value : T
+
+        throw new Error();
+>new Error() : Error
+>Error : ErrorConstructor
+    }
+
+    /** @returns {typeof A} */
+    static extend() {
+>extend : () => typeof A
+
+        return this;
+>this : typeof A
+    }
+}
+
+/** @extends {A<string>} */
+class B extends A.extend() {}
+>B : B
+>A.extend() : A<string>
+>A.extend : () => typeof A
+>A : typeof A
+>extend : () => typeof A
+
+const value = new B().value;
+>value : string
+>new B().value : string
+>new B() : B
+>B : typeof B
+>value : string
+

tsc/testdata/tests/cases/conformance/jsdoc/extendsTag7.ts

@@ -0,0 +1,23 @@
+// @target: es2015
+// @allowJs: true
+// @checkJs: true
+// @noEmit: true
+
+// @filename: a.js
+/** @template T */
+class A {
+    /** @returns {T} */
+    get value() {
+        throw new Error();
+    }
+
+    /** @returns {typeof A} */
+    static extend() {
+        return this;
+    }
+}
+
+/** @extends {A<string>} */
+class B extends A.extend() {}
+
+const value = new B().value;