Reapply #1951 and #1960 after bad merge (#1964)

Co-authored-by: Anders Hejlsberg <andersh@microsoft.com>
Co-authored-by: John Favret <64748847+johnfav03@users.noreply.github.com>

Author: 3 people

internal/ast/ast.go

@@ -2353,6 +2353,9 @@ func IsArrayLiteralOrObjectLiteralDestructuringPattern(node *Node) bool {
 
 func accessKind(node *Node) AccessKind {
 	parent := node.Parent
+	if parent == nil {
+		return AccessKindRead
+	}
 	switch parent.Kind {
 	case KindParenthesizedExpression:
 		return accessKind(parent)
@@ -2404,8 +2407,9 @@ func accessKind(node *Node) AccessKind {
 			return AccessKindWrite
 		}
 		return AccessKindRead
+	default:
+		return AccessKindRead
 	}
-	return AccessKindRead
 }
 
 func reverseAccessKind(a AccessKind) AccessKind {

internal/ast/utilities.go

@@ -571,7 +571,7 @@ func IsClassElement(node *Node) bool {
 	return false
 }
 
-func isMethodOrAccessor(node *Node) bool {
+func IsMethodOrAccessor(node *Node) bool {
 	switch node.Kind {
 	case KindMethodDeclaration, KindGetAccessor, KindSetAccessor:
 		return true
@@ -580,7 +580,7 @@ func isMethodOrAccessor(node *Node) bool {
 }
 
 func IsPrivateIdentifierClassElementDeclaration(node *Node) bool {
-	return (IsPropertyDeclaration(node) || isMethodOrAccessor(node)) && IsPrivateIdentifier(node.Name())
+	return (IsPropertyDeclaration(node) || IsMethodOrAccessor(node)) && IsPrivateIdentifier(node.Name())
 }
 
 func IsObjectLiteralOrClassExpressionMethodOrAccessor(node *Node) bool {

internal/checker/checker.go

@@ -19101,11 +19101,9 @@ func (c *Checker) getSignaturesOfSymbol(symbol *ast.Symbol) []*Signature {
 		}
 		// If this is a function or method declaration, get the signature from the @type tag for the sake of optional parameters.
 		// Exclude contextually-typed kinds because we already apply the @type tag to the context, plus applying it here to the initializer would suppress checks that the two are compatible.
-		if ast.IsFunctionExpressionOrArrowFunction(decl) || ast.IsObjectLiteralMethod(decl) {
-			if sig := c.getSignatureOfFullSignatureType(decl); sig != nil {
-				result = append(result, sig)
-				continue
-			}
+		if sig := c.getSignatureOfFullSignatureType(decl); sig != nil {
+			result = append(result, sig)
+			continue
 		}
 		result = append(result, c.getSignatureFromDeclaration(decl))
 	}
@@ -19123,6 +19121,14 @@ func (c *Checker) getSignatureFromDeclaration(declaration *ast.Node) *Signature
 	minArgumentCount := 0
 	hasThisParameter := false
 	iife := ast.GetImmediatelyInvokedFunctionExpression(declaration)
+	isUntypedSignatureInJSFile := iife == nil &&
+		ast.IsInJSFile(declaration) &&
+		(ast.IsFunctionExpression(declaration) || ast.IsArrowFunction(declaration) || ast.IsMethodOrAccessor(declaration) || ast.IsFunctionDeclaration(declaration) || ast.IsConstructorDeclaration(declaration)) &&
+		core.Every(declaration.Parameters(), func(param *ast.Node) bool { return param.Type() == nil }) &&
+		c.getContextualType(declaration, ContextFlagsSignature) == nil
+	if isUntypedSignatureInJSFile {
+		flags |= SignatureFlagsIsUntypedSignatureInJSFile
+	}
 	for i, param := range declaration.Parameters() {
 		paramSymbol := param.Symbol()
 		typeNode := param.Type()
@@ -19343,7 +19349,7 @@ func (c *Checker) getReturnTypeFromAnnotation(declaration *ast.Node) *Type {
 }
 
 func (c *Checker) getSignatureOfFullSignatureType(node *ast.Node) *Signature {
-	if ast.IsInJSFile(node) && ast.IsFunctionLike(node) && node.FunctionLikeData().FullSignature != nil {
+	if ast.IsInJSFile(node) && (ast.IsFunctionDeclaration(node) || ast.IsMethodDeclaration(node) || ast.IsFunctionExpressionOrArrowFunction(node)) && node.FunctionLikeData().FullSignature != nil {
 		return c.getSingleCallSignature(c.getTypeFromTypeNode(node.FunctionLikeData().FullSignature))
 	}
 	return nil

internal/checker/emitresolver.go

@@ -458,13 +458,20 @@ func (r *emitResolver) IsImplementationOfOverload(node *ast.SignatureDeclaration
 		//       function foo(a: any) { // This is implementation of the overloads
 		//           return a;
 		//       }
-		return len(signaturesOfSymbol) > 1 ||
-			// If there is single signature for the symbol, it is overload if that signature isn't coming from the node
-			// e.g.: function foo(a: string): string;
-			//       function foo(a: any) { // This is implementation of the overloads
-			//           return a;
-			//       }
-			(len(signaturesOfSymbol) == 1 && signaturesOfSymbol[0].declaration != node)
+		if len(signaturesOfSymbol) > 1 {
+			return true
+		}
+		// If there is single signature for the symbol, it is overload if that signature isn't coming from the node
+		// e.g.: function foo(a: string): string;
+		//       function foo(a: any) { // This is implementation of the overloads
+		//           return a;
+		//       }
+		if len(signaturesOfSymbol) == 1 {
+			declaration := signaturesOfSymbol[0].declaration
+			if declaration != node && declaration.Flags&ast.NodeFlagsJSDoc == 0 {
+				return true
+			}
+		}
 	}
 	return false
 }

internal/fourslash/tests/documentHighlightReferenceDirective_test.go

@@ -0,0 +1,24 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+func TestDocumentHighlightReferenceDirective(t *testing.T) {
+	t.Parallel()
+
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @Filename: /a.ts
+/// <reference path="[|./b.ts|]" />
+
+const x = 1;
+
+// @filename: b.ts
+export type Foo = number;
+`
+	f := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	f.VerifyBaselineDocumentHighlights(t, nil /*preferences*/, f.Ranges()[0])
+}

internal/ls/documenthighlights.go

@@ -56,14 +56,13 @@ func (l *LanguageService) getSemanticDocumentHighlights(ctx context.Context, pos
 	if referenceEntries == nil {
 		return nil
 	}
+
 	var highlights []*lsproto.DocumentHighlight
 	for _, entry := range referenceEntries {
 		for _, ref := range entry.references {
-			if ref.node != nil {
-				fileName, highlight := l.toDocumentHighlight(ref)
-				if fileName == sourceFile.FileName() {
-					highlights = append(highlights, highlight)
-				}
+			fileName, highlight := l.toDocumentHighlight(ref)
+			if fileName == sourceFile.FileName() {
+				highlights = append(highlights, highlight)
 			}
 		}
 	}

internal/ls/findallreferences.go

@@ -625,7 +625,7 @@ func (l *LanguageService) getReferencedSymbolsForNode(ctx context.Context, posit
 		}
 
 		if moduleSymbol := checker.GetMergedSymbol(resolvedRef.file.Symbol); moduleSymbol != nil {
-			return getReferencedSymbolsForModule(ctx, program, moduleSymbol /*excludeImportTypeOfExportEquals*/, false, sourceFiles, sourceFilesSet)
+			return l.getReferencedSymbolsForModule(ctx, program, moduleSymbol /*excludeImportTypeOfExportEquals*/, false, sourceFiles, sourceFilesSet)
 		}
 
 		// !!! not implemented
@@ -673,7 +673,7 @@ func (l *LanguageService) getReferencedSymbolsForNode(ctx context.Context, posit
 	}
 
 	if symbol.Name == ast.InternalSymbolNameExportEquals {
-		return getReferencedSymbolsForModule(ctx, program, symbol.Parent, false /*excludeImportTypeOfExportEquals*/, sourceFiles, sourceFilesSet)
+		return l.getReferencedSymbolsForModule(ctx, program, symbol.Parent, false /*excludeImportTypeOfExportEquals*/, sourceFiles, sourceFilesSet)
 	}
 
 	moduleReferences := l.getReferencedSymbolsForModuleIfDeclaredBySourceFile(ctx, symbol, program, sourceFiles, checker, options, sourceFilesSet) // !!! cancellationToken
@@ -700,7 +700,7 @@ func (l *LanguageService) getReferencedSymbolsForModuleIfDeclaredBySourceFile(ct
 	}
 	exportEquals := symbol.Exports[ast.InternalSymbolNameExportEquals]
 	// If exportEquals != nil, we're about to add references to `import("mod")` anyway, so don't double-count them.
-	moduleReferences := getReferencedSymbolsForModule(ctx, program, symbol, exportEquals != nil, sourceFiles, sourceFilesSet)
+	moduleReferences := l.getReferencedSymbolsForModule(ctx, program, symbol, exportEquals != nil, sourceFiles, sourceFilesSet)
 	if exportEquals == nil || !sourceFilesSet.Has(moduleSourceFileName) {
 		return moduleReferences
 	}
@@ -1021,7 +1021,7 @@ func getMergedAliasedSymbolOfNamespaceExportDeclaration(node *ast.Node, symbol *
 	return nil
 }
 
-func getReferencedSymbolsForModule(ctx context.Context, program *compiler.Program, symbol *ast.Symbol, excludeImportTypeOfExportEquals bool, sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string]) []*SymbolAndEntries {
+func (l *LanguageService) getReferencedSymbolsForModule(ctx context.Context, program *compiler.Program, symbol *ast.Symbol, excludeImportTypeOfExportEquals bool, sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string]) []*SymbolAndEntries {
 	debug.Assert(symbol.ValueDeclaration != nil)
 
 	checker, done := program.GetTypeChecker(ctx)
@@ -1062,10 +1062,11 @@ func getReferencedSymbolsForModule(ctx context.Context, program *compiler.Progra
 			}
 			return newNodeEntry(rangeNode)
 		case ModuleReferenceKindReference:
-			// <reference path> or <reference types>
-			// We can't easily create a proper range entry here without access to LanguageService,
-			// but we can create a node-based entry pointing to the source file which will be resolved later
-			return newNodeEntry(reference.referencingFile.AsNode())
+			return &referenceEntry{
+				kind:      entryKindRange,
+				fileName:  reference.referencingFile.FileName(),
+				textRange: l.createLspRangeFromBounds(reference.ref.Pos(), reference.ref.End(), reference.referencingFile),
+			}
 		}
 		return nil
 	})

testdata/baselines/reference/conformance/jsdocTypeParameterTagConflict.types

@@ -6,7 +6,7 @@
  * @param {2} a
  */
 export function conflictingParam(a) { return true }
->conflictingParam : (a: 2) => true
+>conflictingParam : (a: 1) => true
 >a : 2
 >true : true
 
@@ -15,7 +15,7 @@ export function conflictingParam(a) { return true }
  * @return {false}
  */
 export function conflictingReturn(b) { return false }
->conflictingReturn : (b: 3) => false
+>conflictingReturn : (b: 3) => true
 >b : 3
 >false : false
 
@@ -26,7 +26,7 @@ export function conflictingReturn(b) { return false }
  * @return {false}
  */
 export function conflictingBoth(d) { return false }
->conflictingBoth : (d: 5) => false
+>conflictingBoth : (c: 4) => true
 >d : 5
 >false : false
 

testdata/baselines/reference/fourslash/documentHighlights/documentHighlightReferenceDirective.baseline.jsonc

@@ -0,0 +1,6 @@
+// === documentHighlights ===
+// === /a.ts ===
+// /// <reference path="/*HIGHLIGHTS*/[|./b.ts|]" />
+// 
+// const x = 1;
+// 

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

@@ -1,22 +1,18 @@
 main.js(3,9): error TS2554: Expected 0 arguments, but got 3.
-main.js(5,1): error TS2554: Expected 2 arguments, but got 0.
-main.js(6,16): error TS2554: Expected 2 arguments, but got 3.
+main.js(6,16): error TS2554: Expected 0-2 arguments, but got 3.
 
 
-==== main.js (3 errors) ====
+==== main.js (2 errors) ====
     function allRest() { arguments; }
     allRest();
     allRest(1, 2, 3);
             ~~~~~~~
 !!! error TS2554: Expected 0 arguments, but got 3.
     function someRest(x, y) { arguments; }
     someRest(); // x and y are still optional because they are in a JS file
-    ~~~~~~~~
-!!! error TS2554: Expected 2 arguments, but got 0.
-!!! related TS6210 main.js:4:19: An argument for 'x' was not provided.
     someRest(1, 2, 3);
                    ~
-!!! error TS2554: Expected 2 arguments, but got 3.
+!!! error TS2554: Expected 0-2 arguments, but got 3.
 
     /**
      * @param {number} x - a thing