Ensure nodes have real parents, fix parent race (#970)

Author: andrewbranch

internal/ast/ast.go

@@ -9643,9 +9643,10 @@ func (node *JSDocThisTag) Clone(f NodeFactoryCoercible) *Node {
 // JSDocImportTag
 type JSDocImportTag struct {
 	JSDocTagBase
-	ImportClause    *Declaration
-	ModuleSpecifier *Expression
-	Attributes      *Node
+	JSImportDeclaration *ImportDeclaration
+	ImportClause        *Declaration
+	ModuleSpecifier     *Expression
+	Attributes          *Node
 }
 
 func (f *NodeFactory) NewJSDocImportTag(tagName *IdentifierNode, importClause *Declaration, moduleSpecifier *Node, attributes *Node, comment *NodeList) *Node {

internal/binder/binder.go

@@ -581,7 +581,9 @@ func (b *Binder) bind(node *ast.Node) bool {
 	if node == nil {
 		return false
 	}
-	node.Parent = b.parent
+	if node.Parent == nil || node.Parent.Flags&ast.NodeFlagsReparsed != 0 {
+		node.Parent = b.parent
+	}
 	saveInStrictMode := b.inStrictMode
 	// Even though in the AST the jsdoc @typedef node belongs to the current node,
 	// its symbol might be in the same scope with the current node's symbol. Consider:

internal/checker/checker.go

@@ -13848,6 +13848,9 @@ 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)
 	}
@@ -14219,6 +14222,8 @@ 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:

internal/checker/grammarchecks.go

@@ -2117,7 +2117,7 @@ func (c *Checker) checkGrammarBigIntLiteral(node *ast.BigIntLiteral) bool {
 }
 
 func (c *Checker) checkGrammarImportClause(node *ast.ImportClause) bool {
-	if node.IsTypeOnly && node.Name() != nil && node.NamedBindings != nil {
+	if node.Flags&ast.NodeFlagsJSDoc == 0 && node.IsTypeOnly && node.Name() != nil && node.NamedBindings != nil {
 		return c.grammarErrorOnNode(&node.Node, diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both)
 	}
 	if node.IsTypeOnly && node.NamedBindings != nil && node.NamedBindings.Kind == ast.KindNamedImports {

internal/checker/utilities.go

@@ -1918,18 +1918,23 @@ func containsNonMissingUndefinedType(c *Checker, t *Type) bool {
 }
 
 func getAnyImportSyntax(node *ast.Node) *ast.Node {
+	var importNode *ast.Node
 	switch node.Kind {
 	case ast.KindImportEqualsDeclaration:
-		return node
+		importNode = node
 	case ast.KindImportClause:
-		return node.Parent
+		importNode = node.Parent
 	case ast.KindNamespaceImport:
-		return node.Parent.Parent
+		importNode = node.Parent.Parent
 	case ast.KindImportSpecifier:
-		return node.Parent.Parent.Parent
+		importNode = node.Parent.Parent.Parent
 	default:
 		return nil
 	}
+	if importNode.Kind == ast.KindJSDocImportTag {
+		return importNode.AsJSDocImportTag().JSImportDeclaration.AsNode()
+	}
+	return importNode
 }
 
 // A reserved member name consists of the byte 0xFE (which is an invalid UTF-8 encoding) followed by one or more

internal/parser/reparser.go

@@ -98,6 +98,7 @@ func (p *Parser) reparseTags(parent *ast.Node, jsDoc []*ast.Node) {
 				importDeclaration.Loc = core.NewTextRange(tag.Pos(), tag.End())
 				importDeclaration.Flags = p.contextFlags | ast.NodeFlagsReparsed
 				p.reparseList = append(p.reparseList, importDeclaration)
+				importTag.JSImportDeclaration = importDeclaration.AsImportDeclaration()
 				// !!! @overload and other unattached tags (@callback et al) support goes here
 			}
 			if !isLast {

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

@@ -0,0 +1,39 @@
+index.js(2,28): error TS2304: Cannot find name 'B'.
+index.js(2,42): error TS2304: Cannot find name 'A'.
+index.js(2,48): error TS2304: Cannot find name 'B'.
+index.js(2,67): error TS2304: Cannot find name 'B'.
+
+
+==== index.js (4 errors) ====
+    /**
+     * @typedef {{ [K in keyof B]: { fn: (a: A, b: B) => void; thing: B[K]; } }} Funcs
+                               ~
+!!! error TS2304: Cannot find name 'B'.
+                                             ~
+!!! error TS2304: Cannot find name 'A'.
+                                                   ~
+!!! error TS2304: Cannot find name 'B'.
+                                                                      ~
+!!! error TS2304: Cannot find name 'B'.
+     * @template A
+     * @template {Record<string, unknown>} B
+     */
+    
+    /**
+     * @template A
+     * @template {Record<string, unknown>} B
+     * @param {Funcs<A, B>} fns
+     * @returns {[A, B]}
+     */
+    function foo(fns) {
+      return /** @type {any} */ (null);
+    }
+    
+    const result = foo({
+      bar: {
+        fn:
+          /** @param {string} a */
+          (a) => {},
+        thing: "asd",
+      },
+    });

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

@@ -14,18 +14,18 @@
  * @returns {[A, B]}
  */
 function foo(fns) {
->foo : <A, B extends Record<string, unknown>>(fns: Funcs<A, B>) => [A, B]
->fns : Funcs<A, B>
+>foo : <A, B extends Record<string, unknown>>(fns: { [x: string]: { fn: (a: A, b: B) => void; thing: B; }; }) => [A, B]
+>fns : { [x: string]: { fn: (a: A, b: B) => void; thing: B; }; }
 
   return /** @type {any} */ (null);
 >(null) : any
 >null : any
 }
 
 const result = foo({
->result : [string, { bar: string; }]
->foo({  bar: {    fn:      /** @param {string} a */      (a) => {},    thing: "asd",  },}) : [string, { bar: string; }]
->foo : <A, B extends Record<string, unknown>>(fns: Funcs<A, B>) => [A, B]
+>result : [unknown, Record<string, unknown>]
+>foo({  bar: {    fn:      /** @param {string} a */      (a) => {},    thing: "asd",  },}) : [unknown, Record<string, unknown>]
+>foo : <A, B extends Record<string, unknown>>(fns: { [x: string]: { fn: (a: A, b: B) => void; thing: B; }; }) => [A, B]
 >{  bar: {    fn:      /** @param {string} a */      (a) => {},    thing: "asd",  },} : { bar: { fn: (a: string) => void; thing: string; }; }
 
   bar: {

testdata/baselines/reference/submodule/conformance/importTag16.errors.txt

@@ -30,22 +30,22 @@ module.exports = Timer;
  * @param {HookHandler} handle
  */
 function Hook(handle) {
->Hook : (handle: HookHandler) => void
->handle : HookHandler
+>Hook : (handle: (arg: any) => void) => void
+>handle : (arg: any) => void
 
     this.handle = handle;
->this.handle = handle : HookHandler
+>this.handle = handle : (arg: any) => void
 >this.handle : any
 >this : any
 >handle : any
->handle : HookHandler
+>handle : (arg: any) => void
 }
 module.exports = Hook;
->module.exports = Hook : (handle: HookHandler) => void
->module.exports : (handle: HookHandler) => void
->module : { Hook(handle: HookHandler): void; }
->exports : (handle: HookHandler) => void
->Hook : (handle: HookHandler) => void
+>module.exports = Hook : (handle: (arg: any) => void) => void
+>module.exports : (handle: (arg: any) => void) => void
+>module : { Hook(handle: (arg: any) => void): void; }
+>exports : (handle: (arg: any) => void) => void
+>Hook : (handle: (arg: any) => void) => void
 
 === context.js ===
 /**