preserve jsdoc base identity for call-expression heritage

Author: a-tarasyuk

tsc/internal/ast/utilities.go

@@ -1645,24 +1645,12 @@ func IsDottedName(node *Node) bool {
 	return false
 }
 
-func HasSamePropertyAccessName(target, source *Node) bool {
-	target = SkipParentheses(target)
-	source = SkipParentheses(source)
-	if IsCallExpression(target) {
-		target = SkipParentheses(target.Expression())
-		if IsPropertyAccessExpression(target) {
-			if HasSamePropertyAccessName(target, source) {
-				return true
-			}
-			target = SkipParentheses(target.Expression())
-		}
-	}
-	if target.Kind == KindIdentifier && source.Kind == KindIdentifier {
-		return target.Text() == source.Text()
-	}
-	if target.Kind == KindPropertyAccessExpression && source.Kind == KindPropertyAccessExpression {
-		return target.AsPropertyAccessExpression().Name().Text() == source.AsPropertyAccessExpression().Name().Text() &&
-			HasSamePropertyAccessName(target.Expression(), source.Expression())
+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
 }

tsc/internal/parser/parser_test.go

@@ -318,25 +318,32 @@ class A {
 }
 
 /** @extends {A<string>} */
-class B extends A.extend() {}
-
-/** @extends {Other<string>} */
-class C extends A.extend() {}`
+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), 3)
+	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()))
+
+	baseExpression := baseType.Expression()
+	assert.Assert(t, ast.IsAsExpression(baseExpression))
+
+	callExpression := baseExpression.Expression()
+	assert.Assert(t, ast.IsCallExpression(callExpression))
+	assert.Equal(t, scanner.GetTextOfNode(callExpression), "A.extend()")
+
+	typeQuery := baseExpression.Type()
+	assert.Equal(t, typeQuery.Kind, ast.KindTypeQuery)
+	assert.Assert(t, typeQuery.Flags&ast.NodeFlagsReparsed != 0)
 
 	typeArguments := baseType.TypeArguments()
 	assert.Equal(t, len(typeArguments), 1)
@@ -354,18 +361,11 @@ class C extends A.extend() {}`
 
 	tag := tags.Nodes[0]
 	assert.Assert(t, ast.IsJSDocAugmentsTag(tag))
+	assert.Equal(t, ast.GetReparsedNodeForNode(tag.ClassName().Expression()), typeQuery.AsTypeQueryNode().ExprName)
 
 	sourceTypeArguments := tag.ClassName().TypeArguments()
 	assert.Equal(t, len(sourceTypeArguments), 1)
 	assert.Equal(t, ast.GetReparsedNodeForNode(sourceTypeArguments[0]), typeArgument)
-
-	classC := statements[2]
-	assert.Assert(t, ast.IsClassDeclaration(classC))
-
-	mismatchedBaseType := ast.GetClassExtendsHeritageElement(classC)
-	assert.Assert(t, mismatchedBaseType != nil)
-	assert.Assert(t, ast.IsCallExpression(mismatchedBaseType.Expression()))
-	assert.Equal(t, len(mismatchedBaseType.TypeArguments()), 0)
 }
 
 func TestSourceFilePositionMapWithNonASCIIStringLiteral(t *testing.T) {

tsc/internal/parser/reparser.go

@@ -597,21 +597,30 @@ 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 {
+					if ast.IsCallExpression(ast.SkipParentheses(target.Expression)) {
+						typeQuery := p.factory.NewTypeQueryNode(p.addDeepCloneReparse(source.Expression), nil)
+						p.finishReparsedNode(typeQuery, source.Expression)
+						target.Expression = p.makeNewCast(typeQuery, target.Expression, true /*isAssertion*/)
+						p.setReparsedTypeArguments(target, source.TypeArguments)
+					} else if ast.HasSamePropertyAccessName(target.Expression, source.Expression) {
+						p.setReparsedTypeArguments(target, source.TypeArguments)
 					}
 				}
 			}
 		}
 	}
 }
 
+func (p *Parser) setReparsedTypeArguments(target *ast.ExpressionWithTypeArguments, source *ast.NodeList) {
+	typeArguments := p.nodeSliceArena.NewSlice(len(source.Nodes))
+	for i, typeArgument := range source.Nodes {
+		typeArguments[i] = p.addDeepCloneReparse(typeArgument)
+	}
+	target.TypeArguments = p.newNodeList(source.Loc, typeArguments)
+	p.finishMutatedNode(target.AsNode())
+}
+
 func (p *Parser) makeQuestionIfOptional(parameter *ast.JSDocParameterOrPropertyTag) *ast.Node {
 	var questionToken *ast.Node
 	if parameter.IsBracketed || parameter.TypeExpression != nil && parameter.TypeExpression.Type().Kind == ast.KindJSDocOptionalType {

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

@@ -1,7 +1,7 @@
 // @target: es2015
 // @allowJs: true
 // @checkJs: true
-// @noEmit: true
+// @declaration: true
 
 // @filename: a.js
 /** @template T */

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

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