Merge branch 'main' into guyllian.gomez/yarn-pnp

Author: GGomez99

_submodules/TypeScript

@@ -5,7 +5,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
-type JSDocParsingMode int
+type JSDocParsingMode uint8
 
 const (
 	JSDocParsingModeParseAll JSDocParsingMode = iota

internal/ast/parseoptions.go

@@ -4,7 +4,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/core"
 )
 
-type SubtreeFacts int32
+type SubtreeFacts uint32
 
 const (
 	// Facts

internal/ast/subtreefacts.go

@@ -23,6 +23,18 @@ type Symbol struct {
 	GlobalExports                SymbolTable            // Conditional global UMD exports
 }
 
+func (s *Symbol) IsExternalModule() bool {
+	return s.Flags&SymbolFlagsModule != 0 && len(s.Name) > 0 && s.Name[0] == '"'
+}
+
+func (s *Symbol) IsStatic() bool {
+	if s.ValueDeclaration == nil {
+		return false
+	}
+	modifierFlags := s.ValueDeclaration.ModifierFlags()
+	return modifierFlags&ModifierFlagsStatic != 0
+}
+
 // SymbolTable
 
 type SymbolTable map[string]*Symbol

internal/ast/symbol.go

@@ -3526,6 +3526,10 @@ func IsTypeDeclarationName(name *Node) bool {
 		GetNameOfDeclaration(name.Parent) == name
 }
 
+func IsRightSideOfPropertyAccess(node *Node) bool {
+	return node.Parent.Kind == KindPropertyAccessExpression && node.Parent.Name() == node
+}
+
 func IsRightSideOfQualifiedNameOrPropertyAccess(node *Node) bool {
 	parent := node.Parent
 	switch parent.Kind {

internal/ast/utilities.go

@@ -205,13 +205,6 @@ loop:
 					return nil
 				}
 			}
-		case ast.KindArrowFunction:
-			// when targeting ES6 or higher there is no 'arguments' in an arrow function
-			// for lower compile targets the resolved symbol is used to emit an error
-			if r.CompilerOptions.GetEmitScriptTarget() >= core.ScriptTargetES2015 {
-				break
-			}
-			fallthrough
 		case ast.KindMethodDeclaration, ast.KindConstructor, ast.KindGetAccessor, ast.KindSetAccessor, ast.KindFunctionDeclaration:
 			if meaning&ast.SymbolFlagsVariable != 0 && name == "arguments" {
 				result = r.argumentsSymbol()
@@ -354,21 +347,18 @@ func (r *NameResolver) useOuterVariableScopeInParameter(result *ast.Symbol, loca
 			// - optional chaining pre-es2020
 			// - nullish coalesce pre-es2020
 			// - spread assignment in binding pattern pre-es2017
-			target := r.CompilerOptions.GetEmitScriptTarget()
-			if target >= core.ScriptTargetES2015 {
-				functionLocation := location
-				declarationRequiresScopeChange := core.TSUnknown
-				if r.GetRequiresScopeChangeCache != nil {
-					declarationRequiresScopeChange = r.GetRequiresScopeChangeCache(functionLocation)
-				}
-				if declarationRequiresScopeChange == core.TSUnknown {
-					declarationRequiresScopeChange = core.IfElse(core.Some(functionLocation.Parameters(), r.requiresScopeChange), core.TSTrue, core.TSFalse)
-					if r.SetRequiresScopeChangeCache != nil {
-						r.SetRequiresScopeChangeCache(functionLocation, declarationRequiresScopeChange)
-					}
+			functionLocation := location
+			declarationRequiresScopeChange := core.TSUnknown
+			if r.GetRequiresScopeChangeCache != nil {
+				declarationRequiresScopeChange = r.GetRequiresScopeChangeCache(functionLocation)
+			}
+			if declarationRequiresScopeChange == core.TSUnknown {
+				declarationRequiresScopeChange = core.IfElse(core.Some(functionLocation.Parameters(), r.requiresScopeChange), core.TSTrue, core.TSFalse)
+				if r.SetRequiresScopeChangeCache != nil {
+					r.SetRequiresScopeChangeCache(functionLocation, declarationRequiresScopeChange)
 				}
-				return declarationRequiresScopeChange != core.TSTrue
 			}
+			return declarationRequiresScopeChange != core.TSTrue
 		}
 	}
 	return false

internal/binder/nameresolver.go

@@ -3257,9 +3257,6 @@ func (c *Checker) checkFunctionOrMethodDeclaration(node *ast.Node) {
 		if c.getContextualCallSignature(c.getTypeFromTypeNode(node.FunctionLikeData().FullSignature), node) == nil {
 			c.error(node.FunctionLikeData().FullSignature, diagnostics.A_JSDoc_type_tag_on_a_function_must_have_a_signature_with_the_correct_number_of_arguments)
 		}
-		if node.Type() != nil || core.Some(node.Parameters(), func(p *ast.Node) bool { return p.Type() != nil }) {
-			c.error(node.FunctionLikeData().FullSignature, diagnostics.A_JSDoc_type_tag_may_not_occur_with_a_param_or_returns_tag)
-		}
 	}
 	if node.Type() == nil {
 		// Report an implicit any error if there is no body, no explicit return type, and node is not a private method
@@ -5817,6 +5814,7 @@ func (c *Checker) getIteratedTypeOrElementType(use IterationUse, inputType *Type
 		}
 		return nil
 	}
+	// TODO: remove ScriptTargetES2015
 	uplevelIteration := c.languageVersion >= core.ScriptTargetES2015
 	downlevelIteration := !uplevelIteration && c.compilerOptions.DownlevelIteration == core.TSTrue
 	possibleOutOfBounds := c.compilerOptions.NoUncheckedIndexedAccess == core.TSTrue && use&IterationUsePossiblyOutOfBounds != 0
@@ -7675,10 +7673,6 @@ func (c *Checker) checkSuperExpression(node *ast.Node) *Type {
 	// 	c.captureLexicalThis(node.Parent, container)
 	// }
 	if container.Parent.Kind == ast.KindObjectLiteralExpression {
-		if c.languageVersion < core.ScriptTargetES2015 {
-			c.error(node, diagnostics.X_super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher)
-			return c.errorType
-		}
 		// for object literal assume that type of 'super' is 'any'
 		return c.anyType
 	}
@@ -9833,9 +9827,6 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c
 		if c.getContextualCallSignature(c.getTypeFromTypeNode(node.FunctionLikeData().FullSignature), node) == nil {
 			c.error(node.FunctionLikeData().FullSignature, diagnostics.A_JSDoc_type_tag_on_a_function_must_have_a_signature_with_the_correct_number_of_arguments)
 		}
-		if node.Type() != nil || core.Some(node.Parameters(), func(p *ast.Node) bool { return p.Type() != nil }) {
-			c.error(node.FunctionLikeData().FullSignature, diagnostics.A_JSDoc_type_tag_may_not_occur_with_a_param_or_returns_tag)
-		}
 	}
 	c.contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode)
 	return c.getTypeOfSymbol(c.getSymbolOfDeclaration(node))
@@ -11343,14 +11334,6 @@ func (c *Checker) checkPropertyAccessibilityAtLocation(location *ast.Node, isSup
 		// - In a static member function or static member accessor
 		//   where this references the constructor function object of a derived class,
 		//   a super property access is permitted and must specify a public static member function of the base class.
-		if c.languageVersion < core.ScriptTargetES2015 {
-			if c.symbolHasNonMethodDeclaration(prop) {
-				if errorNode != nil {
-					c.error(errorNode, diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword)
-				}
-				return false
-			}
-		}
 		if flags&ast.ModifierFlagsAbstract != 0 {
 			// A method cannot be accessed in a super property access if the method is abstract.
 			// This error could mask a private property access error. But, a member
@@ -11689,12 +11672,11 @@ func (c *Checker) TryGetThisTypeAtEx(node *ast.Node, includeGlobalThis bool, con
 		container = c.getThisContainer(node, false /*includeArrowFunctions*/, false /*includeClassComputedPropertyName*/)
 	}
 	if ast.IsFunctionLike(container) && (!c.isInParameterInitializerBeforeContainingFunction(node) || ast.GetThisParameter(container) != nil) {
-		thisType := c.getThisTypeOfDeclaration(container)
-		if thisType == nil && ast.IsInJSFile(container) {
-			if sig := c.getSignatureOfFullSignatureType(container); sig != nil {
-				thisType = c.getThisTypeOfSignature(sig)
-			}
+		sig := c.getSignatureOfFullSignatureType(container)
+		if sig == nil {
+			sig = c.getSignatureFromDeclaration(container)
 		}
+		thisType := c.getThisTypeOfSignature(sig)
 		// Note: a parameter initializer should refer to class-this unless function-this is explicitly annotated.
 		// If this is a function in a JS file, it might be a class method.
 		if thisType == nil {
@@ -11793,10 +11775,6 @@ func (c *Checker) isInParameterInitializerBeforeContainingFunction(node *ast.Nod
 	return false
 }
 
-func (c *Checker) getThisTypeOfDeclaration(declaration *ast.Node) *Type {
-	return c.getThisTypeOfSignature(c.getSignatureFromDeclaration(declaration))
-}
-
 func (c *Checker) checkThisInStaticClassFieldInitializerInDecoratedClass(thisExpression *ast.Node, container *ast.Node) {
 	if ast.IsPropertyDeclaration(container) && ast.HasStaticModifier(container) && c.legacyDecorators {
 		initializer := container.Initializer()
@@ -17356,6 +17334,7 @@ func (c *Checker) getTypeFromArrayBindingPattern(pattern *ast.Node, includePatte
 		restElement = lastElement
 	}
 	if len(elements) == 0 || len(elements) == 1 && restElement != nil {
+		// TODO: remove ScriptTargetES2015
 		if c.languageVersion >= core.ScriptTargetES2015 {
 			return c.createIterableType(c.anyType)
 		}
@@ -19101,11 +19080,11 @@ 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 sig := c.getSignatureOfFullSignatureType(decl); sig != nil {
-			result = append(result, sig)
-			continue
+		sig := c.getSignatureOfFullSignatureType(decl)
+		if sig == nil {
+			sig = c.getSignatureFromDeclaration(decl)
 		}
-		result = append(result, c.getSignatureFromDeclaration(decl))
+		result = append(result, sig)
 	}
 	return result
 }
@@ -19187,15 +19166,13 @@ func (c *Checker) getSignatureFromDeclaration(declaration *ast.Node) *Signature
 }
 
 func (c *Checker) getTypeParametersFromDeclaration(declaration *ast.Node) []*Type {
+	if sig := c.getSignatureOfFullSignatureType(declaration); sig != nil {
+		return sig.TypeParameters()
+	}
 	var result []*Type
 	for _, node := range declaration.TypeParameters() {
 		result = core.AppendIfUnique(result, c.getDeclaredTypeOfTypeParameter(node.Symbol()))
 	}
-	if len(result) == 0 && ast.IsFunctionDeclaration(declaration) {
-		if sig := c.getSignatureOfFullSignatureType(declaration); sig != nil {
-			return sig.TypeParameters()
-		}
-	}
 	return result
 }
 

internal/checker/checker.go

@@ -1338,9 +1338,6 @@ func (c *Checker) checkGrammarForInOrForOfStatement(forInOrOfStatement *ast.ForI
 func (c *Checker) checkGrammarAccessor(accessor *ast.AccessorDeclaration) bool {
 	body := accessor.Body()
 	if accessor.Flags&ast.NodeFlagsAmbient == 0 && (accessor.Parent.Kind != ast.KindTypeLiteral) && (accessor.Parent.Kind != ast.KindInterfaceDeclaration) {
-		if c.languageVersion < core.ScriptTargetES2015 && ast.IsPrivateIdentifier(accessor.Name()) {
-			return c.grammarErrorOnNode(accessor.Name(), diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher)
-		}
 		if body == nil && !ast.HasSyntacticModifier(accessor, ast.ModifierFlagsAbstract) {
 			return c.grammarErrorAtPos(accessor, accessor.End()-1, len(";"), diagnostics.X_0_expected, "{")
 		}
@@ -1492,9 +1489,6 @@ func (c *Checker) checkGrammarMethod(node *ast.Node /*Union[MethodDeclaration, M
 	}
 
 	if ast.IsClassLike(node.Parent) {
-		if c.languageVersion < core.ScriptTargetES2015 && ast.IsPrivateIdentifier(node.Name()) {
-			return c.grammarErrorOnNode(node.Name(), diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher)
-		}
 		// Technically, computed properties in ambient contexts is disallowed
 		// for property declarations and accessors too, not just methods.
 		// However, property declarations disallow computed names in general,
@@ -1934,12 +1928,6 @@ func (c *Checker) checkGrammarProperty(node *ast.Node /*Union[PropertyDeclaratio
 		if c.checkGrammarForInvalidDynamicName(propertyName, diagnostics.A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type) {
 			return true
 		}
-		if c.languageVersion < core.ScriptTargetES2015 && ast.IsPrivateIdentifier(propertyName) {
-			return c.grammarErrorOnNode(propertyName, diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher)
-		}
-		if c.languageVersion < core.ScriptTargetES2015 && ast.IsAutoAccessorPropertyDeclaration(node) && node.Flags&ast.NodeFlagsAmbient == 0 {
-			return c.grammarErrorOnNode(propertyName, diagnostics.Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher)
-		}
 		if ast.IsAutoAccessorPropertyDeclaration(node) && c.checkGrammarForInvalidQuestionMark(node.AsPropertyDeclaration().PostfixToken, diagnostics.An_accessor_property_cannot_be_declared_optional) {
 			return true
 		}

internal/checker/grammarchecks.go

@@ -1994,19 +1994,11 @@ func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate {
 		default:
 			if sig.declaration != nil {
 				typeNode := sig.declaration.Type()
-				var jsdocTypePredicate *TypePredicate
-				if typeNode == nil {
-					if jsdocSignature := c.getSignatureOfFullSignatureType(sig.declaration); jsdocSignature != nil {
-						jsdocTypePredicate = c.getTypePredicateOfSignature(jsdocSignature)
-					}
-				}
 				switch {
 				case typeNode != nil:
 					if ast.IsTypePredicateNode(typeNode) {
 						sig.resolvedTypePredicate = c.createTypePredicateFromTypePredicateNode(typeNode, sig)
 					}
-				case jsdocTypePredicate != nil:
-					sig.resolvedTypePredicate = jsdocTypePredicate
 				case ast.IsFunctionLikeDeclaration(sig.declaration) && (sig.resolvedReturnType == nil || sig.resolvedReturnType.flags&TypeFlagsBoolean != 0) && c.getParameterCount(sig) > 0:
 					sig.resolvedTypePredicate = c.noTypePredicate // avoid infinite loop
 					sig.resolvedTypePredicate = c.getTypePredicateFromBody(sig.declaration)

internal/checker/relater.go

@@ -82,7 +82,7 @@ const TypeFormatFlagsNodeBuilderFlagsMask = TypeFormatFlagsNoTruncation | TypeFo
 	TypeFormatFlagsUseTypeOfFunction | TypeFormatFlagsOmitParameterModifiers | TypeFormatFlagsUseAliasDefinedOutsideCurrentScope | TypeFormatFlagsAllowUniqueESSymbolType | TypeFormatFlagsInTypeAlias |
 	TypeFormatFlagsUseSingleQuotesForStringLiteralType | TypeFormatFlagsNoTypeReduction | TypeFormatFlagsOmitThisParameter
 
-type SymbolFormatFlags int32
+type SymbolFormatFlags uint32
 
 const (
 	SymbolFormatFlagsNone SymbolFormatFlags = 0
@@ -1210,20 +1210,6 @@ const (
 type TypeComparer func(s *Type, t *Type, reportErrors bool) Ternary
 
 type LanguageFeatureMinimumTargetMap struct {
-	Classes                           core.ScriptTarget
-	ForOf                             core.ScriptTarget
-	Generators                        core.ScriptTarget
-	Iteration                         core.ScriptTarget
-	SpreadElements                    core.ScriptTarget
-	RestElements                      core.ScriptTarget
-	TaggedTemplates                   core.ScriptTarget
-	DestructuringAssignment           core.ScriptTarget
-	BindingPatterns                   core.ScriptTarget
-	ArrowFunctions                    core.ScriptTarget
-	BlockScopedVariables              core.ScriptTarget
-	ObjectAssign                      core.ScriptTarget
-	RegularExpressionFlagsUnicode     core.ScriptTarget
-	RegularExpressionFlagsSticky      core.ScriptTarget
 	Exponentiation                    core.ScriptTarget
 	AsyncFunctions                    core.ScriptTarget
 	ForAwaitOf                        core.ScriptTarget
@@ -1247,20 +1233,6 @@ type LanguageFeatureMinimumTargetMap struct {
 }
 
 var LanguageFeatureMinimumTarget = LanguageFeatureMinimumTargetMap{
-	Classes:                           core.ScriptTargetES2015,
-	ForOf:                             core.ScriptTargetES2015,
-	Generators:                        core.ScriptTargetES2015,
-	Iteration:                         core.ScriptTargetES2015,
-	SpreadElements:                    core.ScriptTargetES2015,
-	RestElements:                      core.ScriptTargetES2015,
-	TaggedTemplates:                   core.ScriptTargetES2015,
-	DestructuringAssignment:           core.ScriptTargetES2015,
-	BindingPatterns:                   core.ScriptTargetES2015,
-	ArrowFunctions:                    core.ScriptTargetES2015,
-	BlockScopedVariables:              core.ScriptTargetES2015,
-	ObjectAssign:                      core.ScriptTargetES2015,
-	RegularExpressionFlagsUnicode:     core.ScriptTargetES2015,
-	RegularExpressionFlagsSticky:      core.ScriptTargetES2015,
 	Exponentiation:                    core.ScriptTargetES2016,
 	AsyncFunctions:                    core.ScriptTargetES2017,
 	ForAwaitOf:                        core.ScriptTargetES2018,