Merge branch 'main' into fix/typos

Author: RyanCavanaugh

Diff for: .vscode/launch.template.json

@@ -17,6 +17,17 @@
             ],
             "autoAttachChildProcesses": true,
             "preLaunchTask": "Watch for extension run"
+        },
+        {
+            "name": "Launch submodule test",
+            "type": "go",
+            "request": "launch",
+            "mode": "test",
+            "program": "${workspaceFolder}/internal/testrunner",
+            "args": [
+                "-test.run",
+                "TestSubmodule/${fileBasename}"
+            ]
         }
     ]
 }

Diff for: internal/checker/checker.go

@@ -878,7 +878,7 @@ func NewChecker(program Program) *Checker {
 	c.autoType = c.newIntrinsicTypeEx(TypeFlagsAny, "any", ObjectFlagsNonInferrableType)
 	c.wildcardType = c.newIntrinsicType(TypeFlagsAny, "any")
 	c.blockedStringType = c.newIntrinsicType(TypeFlagsAny, "any")
-	c.errorType = c.newIntrinsicType(TypeFlagsAny, "error")
+	c.errorType = c.newIntrinsicType(TypeFlagsAny, "any")
 	c.unresolvedType = c.newIntrinsicType(TypeFlagsAny, "unresolved")
 	c.nonInferrableAnyType = c.newIntrinsicTypeEx(TypeFlagsAny, "any", ObjectFlagsContainsWideningType)
 	c.intrinsicMarkerType = c.newIntrinsicType(TypeFlagsAny, "intrinsic")
@@ -6531,7 +6531,7 @@ func (c *Checker) reportUnusedVariableDeclarations(declarations []*ast.Node) {
 			if ast.IsBindingPattern(name) {
 				c.reportUnusedBindingElements(name)
 			} else if c.isUnreferencedVariableDeclaration(declaration) {
-				c.reportUnusedVariable(declaration, NewDiagnosticForNode(declaration, diagnostics.X_0_is_declared_but_its_value_is_never_read, name.Text()))
+				c.reportUnusedVariable(declaration, NewDiagnosticForNode(name, diagnostics.X_0_is_declared_but_its_value_is_never_read, name.Text()))
 			}
 		}
 	}
@@ -6594,7 +6594,7 @@ func importClauseFromImported(node *ast.Node) *ast.Node {
 func (c *Checker) checkUnusedInferTypeParameter(node *ast.Node) {
 	typeParameter := node.AsInferTypeNode().TypeParameter
 	if c.isUnreferencedTypeParameter(typeParameter) {
-		c.reportUnused(node, UnusedKindParameter, NewDiagnosticForNode(typeParameter, diagnostics.X_0_is_declared_but_never_used, typeParameter.Name().Text()))
+		c.reportUnused(node, UnusedKindParameter, NewDiagnosticForNode(typeParameter.Name(), diagnostics.X_0_is_declared_but_never_used, typeParameter.Name().Text()))
 	}
 }
 

Diff for: internal/checker/printer.go

@@ -18,7 +18,7 @@ func (c *Checker) getTypePrecedence(t *Type) ast.TypePrecedence {
 			return ast.TypePrecedenceIntersection
 		case t.flags&TypeFlagsUnion != 0 && t.flags&TypeFlagsBoolean == 0:
 			return ast.TypePrecedenceUnion
-		case t.flags&TypeFlagsIndex != 0:
+		case t.flags&TypeFlagsIndex != 0 || isInferTypeParameter(t):
 			return ast.TypePrecedenceTypeOperator
 		case c.isArrayType(t):
 			return ast.TypePrecedencePostfix
@@ -98,11 +98,12 @@ func (c *Checker) valueToString(value any) string {
 }
 
 type Printer struct {
-	c        *Checker
-	flags    TypeFormatFlags
-	sb       strings.Builder
-	printing core.Set[*Type]
-	depth    int
+	c                *Checker
+	flags            TypeFormatFlags
+	sb               strings.Builder
+	printing         core.Set[*Type]
+	depth            int32
+	extendsTypeDepth int32
 }
 
 func (c *Checker) newPrinter(flags TypeFormatFlags) *Printer {
@@ -161,6 +162,8 @@ func (p *Printer) printTypeNoAlias(t *Type) {
 		p.printRecursive(t, (*Printer).printIndexType)
 	case t.flags&TypeFlagsIndexedAccess != 0:
 		p.printRecursive(t, (*Printer).printIndexedAccessType)
+	case t.flags&TypeFlagsConditional != 0:
+		p.printRecursive(t, (*Printer).printConditionalType)
 	case t.flags&TypeFlagsTemplateLiteral != 0:
 		p.printTemplateLiteralType(t)
 	case t.flags&TypeFlagsStringMapping != 0:
@@ -364,7 +367,6 @@ func (p *Printer) printAnonymousType(t *Type) {
 			}
 		}
 	}
-
 	props := p.c.getPropertiesOfObjectType(t)
 	callSignatures := p.c.getSignaturesOfType(t, SignatureKindCall)
 	constructSignatures := p.c.getSignaturesOfType(t, SignatureKindConstruct)
@@ -434,7 +436,7 @@ func (p *Printer) printSignature(sig *Signature, returnSeparator string) {
 			if tail {
 				p.print(", ")
 			}
-			p.printName(tp.symbol)
+			p.printTypeParameterAndConstraint(tp)
 			tail = true
 		}
 		p.print(">")
@@ -483,15 +485,27 @@ func (p *Printer) printTypePredicate(pred *TypePredicate) {
 }
 
 func (p *Printer) printTypeParameter(t *Type) {
-	if t.AsTypeParameter().isThisType {
+	switch {
+	case t.AsTypeParameter().isThisType:
 		p.print("this")
-	} else if t.symbol != nil {
+	case p.extendsTypeDepth > 0 && isInferTypeParameter(t):
+		p.print("infer ")
+		p.printTypeParameterAndConstraint(t)
+	case t.symbol != nil:
 		p.printName(t.symbol)
-	} else {
+	default:
 		p.print("???")
 	}
 }
 
+func (p *Printer) printTypeParameterAndConstraint(t *Type) {
+	p.printName(t.symbol)
+	if constraint := p.c.getConstraintOfTypeParameter(t); constraint != nil {
+		p.print(" extends ")
+		p.printType(constraint)
+	}
+}
+
 func (p *Printer) printUnionType(t *Type) {
 	switch {
 	case t.flags&TypeFlagsBoolean != 0:
@@ -538,6 +552,18 @@ func (p *Printer) printIndexedAccessType(t *Type) {
 	p.print("]")
 }
 
+func (p *Printer) printConditionalType(t *Type) {
+	p.printType(t.AsConditionalType().checkType)
+	p.print(" extends ")
+	p.extendsTypeDepth++
+	p.printType(t.AsConditionalType().extendsType)
+	p.extendsTypeDepth--
+	p.print(" ? ")
+	p.printType(p.c.getTrueTypeFromConditionalType(t))
+	p.print(" : ")
+	p.printType(p.c.getFalseTypeFromConditionalType(t))
+}
+
 func (p *Printer) printMappedType(t *Type) {
 	d := t.AsMappedType().declaration
 	p.print("{ ")
@@ -663,3 +689,7 @@ func (c *Checker) formatUnionTypes(types []*Type) []*Type {
 	}
 	return result
 }
+
+func isInferTypeParameter(t *Type) bool {
+	return t.flags&TypeFlagsTypeParameter != 0 && t.symbol != nil && core.Some(t.symbol.Declarations, func(d *ast.Node) bool { return ast.IsInferTypeNode(d.Parent) })
+}

Diff for: internal/core/binarysearch.go

@@ -7,6 +7,9 @@ package core
 // compared, instead of the target element.
 func BinarySearchUniqueFunc[S ~[]E, E any](x S, cmp func(int, E) int) (int, bool) {
 	n := len(x)
+	if n == 0 {
+		return 0, false
+	}
 	low, high := 0, n-1
 	for low <= high {
 		middle := low + ((high - low) >> 1)

Diff for: internal/scanner/scanner.go

@@ -1660,9 +1660,14 @@ func (s *Scanner) scanNumber() ast.Kind {
 				s.tokenFlags |= ast.TokenFlagsContainsLeadingZero
 				fixedPart = digits
 			} else {
+				s.tokenValue = jsnum.FromString(digits).String()
 				s.tokenFlags |= ast.TokenFlagsOctal
-				s.tokenValue = "0o" + digits
-				s.errorAt(diagnostics.Octal_literals_are_not_allowed_Use_the_syntax_0, start, s.pos-start, digits)
+				withMinus := s.token == ast.KindMinusToken
+				literal := core.IfElse(withMinus, "-", "") + "0o" + s.tokenValue
+				if withMinus {
+					start--
+				}
+				s.errorAt(diagnostics.Octal_literals_are_not_allowed_Use_the_syntax_0, start, s.pos-start, literal)
 				return ast.KindNumericLiteral
 			}
 		}

Diff for: internal/testutil/runner/compiler_runner.go renamed to internal/testrunner/compiler_runner.go

@@ -0,0 +1,50 @@
+package runner
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/bundled"
+	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/repo"
+	"github.com/microsoft/typescript-go/internal/tspath"
+	"gotest.tools/v3/assert"
+)
+
+// Runs the new compiler tests and produces baselines (e.g. `test1.symbols`).
+func TestLocal(t *testing.T) { runCompilerTests(t, false) } //nolint:paralleltest
+
+// Runs the old compiler tests, and produces new baselines (e.g. `test1.symbols`)
+// and a diff between the new and old baselines (e.g. `test1.symbols.diff`).
+func TestSubmodule(t *testing.T) { runCompilerTests(t, true) } //nolint:paralleltest
+
+func runCompilerTests(t *testing.T, isSubmodule bool) {
+	t.Parallel()
+
+	if isSubmodule {
+		repo.SkipIfNoTypeScriptSubmodule(t)
+	}
+
+	if !bundled.Embedded {
+		// Without embedding, we'd need to read all of the lib files out from disk into the MapFS.
+		// Just skip this for now.
+		t.Skip("bundled files are not embedded")
+	}
+
+	runners := []*CompilerBaselineRunner{
+		NewCompilerBaselineRunner(TestTypeRegression, isSubmodule),
+		NewCompilerBaselineRunner(TestTypeConformance, isSubmodule),
+	}
+
+	var seenTests core.Set[string]
+	for _, runner := range runners {
+		for _, test := range runner.EnumerateTestFiles() {
+			test = tspath.GetBaseFileName(test)
+			assert.Assert(t, !seenTests.Has(test), "Duplicate test file: %s", test)
+			seenTests.Add(test)
+		}
+	}
+
+	for _, runner := range runners {
+		runner.RunTests(t)
+	}
+}

Diff for: internal/testrunner/compiler_runner_test.go

@@ -150,7 +150,8 @@ func parseOwnConfigOfJsonSourceFile(
 				}
 			} else if keyText != "" {
 				if parentOption.ElementOptions != nil {
-					propertySetErrors = append(propertySetErrors, ast.NewCompilerDiagnostic(diagnostics.Option_build_must_be_the_first_command_line_argument, keyText))
+					// !!! TODO: support suggestion
+					propertySetErrors = append(propertySetErrors, createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, propertyAssignment.Name(), diagnostics.Unknown_compiler_option_0, keyText))
 				} else {
 					// errors = append(errors, ast.NewCompilerDiagnostic(diagnostics.Unknown_compiler_option_0_Did_you_mean_1, keyText, core.FindKey(parentOption.ElementOptions, keyText)))
 				}
@@ -516,21 +517,24 @@ func convertOptionsFromJson[O optionParser](optionsNameMap map[string]*CommandLi
 	var errors []*ast.Diagnostic
 	for key, value := range jsonMap.Entries() {
 		opt, ok := optionsNameMap[key]
+		if !ok {
+			// !!! TODO?: support suggestion
+			errors = append(errors, ast.NewCompilerDiagnostic(diagnostics.Unknown_compiler_option_0, key))
+			continue
+		}
+
 		commandLineOptionEnumMapVal := opt.EnumMap()
 		if commandLineOptionEnumMapVal != nil {
 			val, ok := commandLineOptionEnumMapVal.Get(strings.ToLower(value.(string)))
 			if ok {
 				errors = result.ParseOption(key, val)
 			}
-		} else if ok {
+		} else {
 			convertJson, err := convertJsonOption(opt, value, basePath, nil, nil, nil)
 			errors = append(errors, err...)
 			compilerOptionsErr := result.ParseOption(key, convertJson)
 			errors = append(errors, compilerOptionsErr...)
 		}
-		// else {
-		//     errors.push(createUnknownOptionError(id, diagnostics));
-		// }
 	}
 	return result, errors
 }

Diff for: internal/testutil/runner/runner.go renamed to internal/testrunner/runner.go

@@ -471,6 +471,19 @@ var parseJsonConfigFileTests = []struct {
 			allFileList:    map[string]string{"/tsconfig.base.json": tsconfigWithExtendsAndConfigDir, "/src/index.ts": "", "/src/app.ts": "", "/node_modules/module.ts": "", "/dist/output.js": ""},
 		}},
 	},
+	{
+		title: "reports error for an unknown option",
+		input: []testConfig{{
+			jsonText: `{
+			    "compilerOptions": {
+				"unknown": true
+			    }
+			}`,
+			configFileName: "tsconfig.json",
+			basePath:       "/",
+			allFileList:    map[string]string{"/app.ts": ""},
+		}},
+	},
 }
 
 var tsconfigWithExtends = `{

Diff for: internal/testutil/runner/test_case_parser.go renamed to internal/testrunner/test_case_parser.go

@@ -2,24 +2,24 @@
 
 === /monorepo/core/src/application.ts ===
 import { Constructor } from "@loopback/context";
->Constructor : error
+>Constructor : any
 
 export type ControllerClass = Constructor<any>;
 >ControllerClass : ControllerClass
 
 === /monorepo/core/src/usage.ts ===
 import { ControllerClass } from './application';
->ControllerClass : error
+>ControllerClass : any
 
 import { BindingKey } from '@loopback/context';
 >BindingKey : typeof BindingKey
 
 export const CONTROLLER_CLASS = BindingKey.create<ControllerClass>(null as any); // line in question
 >CONTROLLER_CLASS : BindingKey<ControllerClass>
 >BindingKey.create<ControllerClass>(null as any) : BindingKey<ControllerClass>
->BindingKey.create : <T>(ctor: T) => BindingKey<T>
+>BindingKey.create : <T extends Constructor<any>>(ctor: T) => BindingKey<T>
 >BindingKey : typeof BindingKey
->create : <T>(ctor: T) => BindingKey<T>
+>create : <T extends Constructor<any>>(ctor: T) => BindingKey<T>
 >null as any : any
 
 === /monorepo/context/src/value-promise.d.ts ===
@@ -30,7 +30,7 @@ export type Constructor<T> = (...args: any[]) => T;
 
 === /monorepo/context/src/bindingkey.d.ts ===
 import { Constructor } from "./value-promise"
->Constructor : error
+>Constructor : any
 
 export declare class BindingKey<T> {
 >BindingKey : BindingKey<T>
@@ -40,7 +40,7 @@ export declare class BindingKey<T> {
 >__type : T
 
   static create<T extends Constructor<any>>(ctor: T): BindingKey<T>;
->create : <T>(ctor: T) => BindingKey<T>
+>create : <T extends Constructor<any>>(ctor: T) => BindingKey<T>
 >T : T
 >ctor : T
 }