Deep clone JSDoc

internal/ast/ast.go

@@ -9063,7 +9063,6 @@ func (node *JSDocLinkCode) Name() *DeclarationName {
 
 type JSDocTypeExpression struct {
 	TypeNodeBase
-	Host *Node
 	Type *TypeNode
 }
 
@@ -9321,7 +9320,6 @@ type JSDocTemplateTag struct {
 	JSDocTagBase
 	Constraint     *Node
 	TypeParameters *TypeParameterList
-	Host           *Node
 }
 
 func (f *NodeFactory) NewJSDocTemplateTag(tagName *IdentifierNode, constraint *Node, typeParameters *TypeParameterList, comment *NodeList) *Node {
@@ -9816,10 +9814,9 @@ func (node *JSDocThisTag) Clone(f NodeFactoryCoercible) *Node {
 // JSDocImportTag
 type JSDocImportTag struct {
 	JSDocTagBase
-	JSImportDeclaration *ImportDeclaration
-	ImportClause        *Declaration
-	ModuleSpecifier     *Expression
-	Attributes          *Node
+	ImportClause    *Declaration
+	ModuleSpecifier *Expression
+	Attributes      *Node
 }
 
 func (f *NodeFactory) NewJSDocImportTag(tagName *IdentifierNode, importClause *Declaration, moduleSpecifier *Node, attributes *Node, comment *NodeList) *Node {

internal/ast/deepclone.go

@@ -3,7 +3,7 @@ package ast
 import "github.com/microsoft/typescript-go/internal/core"
 
 // Ideally, this would get cached on the node factory so there's only ever one set of closures made per factory
-func getDeepCloneVisitor(f *NodeFactory) *NodeVisitor {
+func getDeepCloneVisitor(f *NodeFactory, syntheticLocation bool) *NodeVisitor {
 	var visitor *NodeVisitor
 	visitor = NewNodeVisitor(
 		func(node *Node) *Node {
@@ -15,7 +15,9 @@ func getDeepCloneVisitor(f *NodeFactory) *NodeVisitor {
 			// In strada, `factory.cloneNode` was dynamic and did _not_ clone positions for any "special cases", meanwhile
 			// Node.Clone in corsa reliably uses `Update` calls for all nodes and so copies locations by default.
 			// Deep clones are done to copy a node across files, so here, we explicitly make the location range synthetic on all cloned nodes
-			c.Loc = core.NewTextRange(-1, -1)
+			if syntheticLocation {
+				c.Loc = core.NewTextRange(-1, -1)
+			}
 			return c
 		},
 		f,
@@ -46,5 +48,18 @@ func getDeepCloneVisitor(f *NodeFactory) *NodeVisitor {
 }
 
 func (f *NodeFactory) DeepCloneNode(node *Node) *Node {
-	return getDeepCloneVisitor(f).VisitNode(node)
+	return getDeepCloneVisitor(f, true /*syntheticLocation*/).VisitNode(node)
+}
+
+func (f *NodeFactory) DeepCloneReparse(node *Node) *Node {
+	if node != nil {
+		node = getDeepCloneVisitor(f, false /*syntheticLocation*/).VisitNode(node)
+		SetParentInChildren(node)
+		node.Flags |= NodeFlagsReparsed
+	}
+	return node
+}
+
+func (f *NodeFactory) DeepCloneReparseModifiers(modifiers *ModifierList) *ModifierList {
+	return getDeepCloneVisitor(f, false /*syntheticLocation*/).VisitModifiers(modifiers)
 }

internal/ast/utilities.go

@@ -867,17 +867,6 @@ func WalkUpParenthesizedTypes(node *TypeNode) *Node {
 	return node
 }
 
-func GetEffectiveTypeParent(parent *Node) *Node {
-	if parent != nil && IsInJSFile(parent) {
-		if parent.Kind == KindJSDocTypeExpression && parent.AsJSDocTypeExpression().Host != nil {
-			parent = parent.AsJSDocTypeExpression().Host
-		} else if parent.Kind == KindJSDocTemplateTag && parent.AsJSDocTemplateTag().Host != nil {
-			parent = parent.AsJSDocTemplateTag().Host
-		}
-	}
-	return parent
-}
-
 // Walks up the parents of a node to find the containing SourceFile
 func GetSourceFileOfNode(node *Node) *SourceFile {
 	for node != nil {
@@ -1466,6 +1455,8 @@ func getAssignedName(node *Node) *Node {
 					}
 				}
 			}
+		case KindCommonJSExport:
+			return parent.AsCommonJSExport().Name()
 		case KindVariableDeclaration:
 			name := parent.AsVariableDeclaration().Name()
 			if IsIdentifier(name) {

internal/binder/binder.go

@@ -1651,8 +1651,6 @@ func (b *Binder) bindChildren(node *ast.Node) {
 	case ast.KindObjectLiteralExpression, ast.KindArrayLiteralExpression, ast.KindPropertyAssignment, ast.KindSpreadElement:
 		b.inAssignmentPattern = saveInAssignmentPattern
 		b.bindEachChild(node)
-	case ast.KindJSExportAssignment, ast.KindCommonJSExport:
-		// Reparsed nodes do not double-bind children, which are not reparsed
 	default:
 		b.bindEachChild(node)
 	}

internal/binder/nameresolver.go

@@ -289,7 +289,7 @@ loop:
 			lastSelfReferenceLocation = location
 		}
 		lastLocation = location
-		location = ast.GetEffectiveTypeParent(location.Parent)
+		location = location.Parent
 	}
 	// We just climbed up parents looking for the name, meaning that we started in a descendant node of `lastLocation`.
 	// If `result === lastSelfReferenceLocation.symbol`, that means that we are somewhere inside `lastSelfReferenceLocation` looking up a name, and resolving to `lastLocation` itself.
@@ -483,9 +483,6 @@ func isTypeParameterSymbolDeclaredInContainer(symbol *ast.Symbol, container *ast
 	for _, decl := range symbol.Declarations {
 		if decl.Kind == ast.KindTypeParameter {
 			parent := decl.Parent
-			if parent.Kind == ast.KindJSDocTemplateTag {
-				parent = parent.AsJSDocTemplateTag().Host
-			}
 			if parent == container {
 				return true
 			}

internal/checker/checker.go

@@ -2903,7 +2903,7 @@ func (c *Checker) checkTypePredicate(node *ast.Node) {
 }
 
 func (c *Checker) getTypePredicateParent(node *ast.Node) *ast.SignatureDeclaration {
-	parent := ast.GetEffectiveTypeParent(node.Parent)
+	parent := node.Parent
 	switch parent.Kind {
 	case ast.KindArrowFunction, ast.KindCallSignature, ast.KindFunctionDeclaration, ast.KindFunctionExpression, ast.KindFunctionType,
 		ast.KindMethodDeclaration, ast.KindMethodSignature:
@@ -13971,9 +13971,6 @@ func (c *Checker) getTargetOfImportSpecifier(node *ast.Node, dontResolveAlias bo
 		}
 	}
 	root := node.Parent.Parent.Parent // ImportDeclaration
-	if root.Kind == ast.KindJSDocImportTag {
-		root = root.AsJSDocImportTag().JSImportDeclaration.AsNode()
-	}
 	if ast.IsBindingElement(node) {
 		root = ast.GetRootDeclaration(node)
 	}
@@ -14344,8 +14341,6 @@ func (c *Checker) getModuleSpecifierForImportOrExport(node *ast.Node) *ast.Node
 
 func getModuleSpecifierFromNode(node *ast.Node) *ast.Node {
 	switch node.Kind {
-	case ast.KindJSDocImportTag:
-		return node.AsJSDocImportTag().JSImportDeclaration.ModuleSpecifier
 	case ast.KindImportDeclaration, ast.KindJSImportDeclaration:
 		return node.AsImportDeclaration().ModuleSpecifier
 	case ast.KindExportDeclaration:
@@ -14449,12 +14444,6 @@ func (c *Checker) resolveExternalModule(location *ast.Node, moduleReference stri
 		contextSpecifier = location.AsVariableDeclaration().Initializer.AsCallExpression().Arguments.Nodes[0]
 	} else {
 		var ancestor *ast.Node
-		if location.Flags&ast.NodeFlagsJSDoc != 0 {
-			ancestor = ast.FindAncestor(location, ast.IsJSDocImportTag)
-			if ancestor != nil {
-				contextSpecifier = ancestor.AsJSDocImportTag().JSImportDeclaration.ModuleSpecifier
-			}
-		}
 		if ancestor == nil {
 			ancestor = ast.FindAncestor(location, ast.IsImportCall)
 			if ancestor != nil {
@@ -22039,7 +22028,6 @@ func (c *Checker) getTypeFromTypeOperatorNode(node *ast.Node) *Type {
 }
 
 func (c *Checker) getESSymbolLikeTypeForNode(node *ast.Node) *Type {
-	node = ast.GetEffectiveTypeParent(node)
 	if isValidESSymbolDeclaration(node) {
 		symbol := c.getSymbolOfNode(node)
 		if symbol != nil {
@@ -22710,9 +22698,9 @@ func (c *Checker) getAliasForTypeNode(node *ast.Node) *TypeAlias {
 }
 
 func (c *Checker) getAliasSymbolForTypeNode(node *ast.Node) *ast.Symbol {
-	host := ast.GetEffectiveTypeParent(node.Parent)
+	host := node.Parent
 	for ast.IsParenthesizedTypeNode(host) || ast.IsTypeOperatorNode(host) && host.AsTypeOperatorNode().Operator == ast.KindReadonlyKeyword {
-		host = ast.GetEffectiveTypeParent(host.Parent)
+		host = host.Parent
 	}
 	if isTypeAlias(host) {
 		return c.getSymbolOfDeclaration(host)
@@ -22748,7 +22736,7 @@ func (c *Checker) getOuterTypeParametersOfClassOrInterface(symbol *ast.Symbol) [
 // Return the outer type parameters of a node or undefined if the node has no outer type parameters.
 func (c *Checker) getOuterTypeParameters(node *ast.Node, includeThisTypes bool) []*Type {
 	for {
-		node = ast.GetEffectiveTypeParent(node.Parent)
+		node = node.Parent
 		if node == nil {
 			return nil
 		}

internal/checker/grammarchecks.go

@@ -1394,7 +1394,7 @@ func (c *Checker) checkGrammarTypeOperatorNode(node *ast.TypeOperatorNode) bool
 		if innerType.Kind != ast.KindSymbolKeyword {
 			return c.grammarErrorOnNode(innerType, diagnostics.X_0_expected, scanner.TokenToString(ast.KindSymbolKeyword))
 		}
-		parent := ast.GetEffectiveTypeParent(ast.WalkUpParenthesizedTypes(node.Parent))
+		parent := ast.WalkUpParenthesizedTypes(node.Parent)
 		switch parent.Kind {
 		case ast.KindVariableDeclaration:
 			decl := parent.AsVariableDeclaration()

internal/checker/utilities.go

@@ -1842,9 +1842,6 @@ func getAnyImportSyntax(node *ast.Node) *ast.Node {
 	default:
 		return nil
 	}
-	if importNode.Kind == ast.KindJSDocImportTag {
-		return importNode.AsJSDocImportTag().JSImportDeclaration.AsNode()
-	}
 	return importNode
 }
 

internal/ls/hover_test.go

@@ -50,6 +50,92 @@ function myFunction() {
 				},
 			},
 		},
+		{
+			title: "JSDocParamHoverFunctionDeclaration",
+			input: `
+// @filename: index.js
+/**
+ * @param {string} param - the greatest of days
+ */
+function /*marker*/myFunction(param) {
+    return "test" + param;
+}
+
+myFunction();`,
+			expected: map[string]*lsproto.Hover{
+				"marker": {
+					Contents: lsproto.MarkupContentOrMarkedStringOrMarkedStrings{
+						MarkupContent: &lsproto.MarkupContent{
+							Kind:  lsproto.MarkupKindMarkdown,
+							Value: "```tsx\nfunction myFunction(param: string): string\n```\n\n\n*@param* `param` - the greatest of days\n",
+						},
+					},
+				},
+			},
+		},
+		{
+			title: "JSDocParamHoverFunctionCall",
+			input: `
+// @filename: index.js
+/**
+ * @param {string} param - the greatest of days
+ */
+function myFunction(param) {
+    return "test" + param;
+}
+
+/*marker*/myFunction();`,
+			expected: map[string]*lsproto.Hover{
+				"marker": {
+					Contents: lsproto.MarkupContentOrMarkedStringOrMarkedStrings{
+						MarkupContent: &lsproto.MarkupContent{
+							Kind:  lsproto.MarkupKindMarkdown,
+							Value: "```tsx\nfunction myFunction(param: string): string\n```\n\n\n*@param* `param` - the greatest of days\n",
+						},
+					},
+				},
+			},
+		},
+		{
+			title: "JSDocParamHoverParameter",
+			input: `
+// @filename: index.js
+/**
+ * @param {string} param - the greatest of days
+ */
+function myFunction(/*marker*/param) {
+    return "test" + param;
+}
+
+myFunction();`,
+			expected: map[string]*lsproto.Hover{
+				"marker": {
+					Contents: lsproto.MarkupContentOrMarkedStringOrMarkedStrings{
+						MarkupContent: &lsproto.MarkupContent{
+							Kind:  lsproto.MarkupKindMarkdown,
+							Value: "```tsx\n(parameter) param: string\n```\n- the greatest of days\n",
+						},
+					},
+				},
+			},
+		},
+		{
+			title: "JSDocParamHoverTagIdentifier",
+			input: `
+// @filename: index.js
+/**
+ * @param {string} /*marker*/param - the greatest of days
+ */
+function myFunction(param) {
+    return "test" + param;
+}
+
+myFunction();`,
+			expected: map[string]*lsproto.Hover{
+				// TODO: Should have same result as hovering on the parameter itself.
+				"marker": nil,
+			},
+		},
 	}
 
 	for _, testCase := range testCases {