More fixes to type checking (#801)

Author: ahejlsberg

internal/ast/ast.go

@@ -113,6 +113,7 @@ func (f *NodeFactory) TextCount() int {
 
 func updateNode(updated *Node, original *Node, hooks NodeFactoryHooks) *Node {
 	if updated != original {
+		updated.Flags = original.Flags
 		updated.Loc = original.Loc
 		if hooks.OnUpdate != nil {
 			hooks.OnUpdate(updated, original)
@@ -8705,6 +8706,10 @@ func (node *JSDocNonNullableType) Clone(f *NodeFactory) *Node {
 	return cloneNode(f.NewJSDocNonNullableType(node.Type), node.AsNode(), f.hooks)
 }
 
+func IsJSDocNonNullableType(node *Node) bool {
+	return node.Kind == KindJSDocNonNullableType
+}
+
 // JSDocNullableType
 
 type JSDocNullableType struct {
@@ -8737,6 +8742,10 @@ func (node *JSDocNullableType) Clone(f *NodeFactory) *Node {
 	return cloneNode(f.NewJSDocNullableType(node.Type), node.AsNode(), f.hooks)
 }
 
+func IsJSDocNullableType(node *Node) bool {
+	return node.Kind == KindJSDocNullableType
+}
+
 // JSDocAllType
 
 type JSDocAllType struct {

internal/ast/utilities.go

@@ -2602,17 +2602,17 @@ func IsUnterminatedLiteral(node *Node) bool {
 }
 
 func GetJSXImplicitImportBase(compilerOptions *core.CompilerOptions, file *SourceFile) string {
-	jsxImportSourcePragma := getPragmaFromSourceFile(file, "jsximportsource")
-	jsxRuntimePragma := getPragmaFromSourceFile(file, "jsxruntime")
-	if getPragmaArgument(jsxRuntimePragma, "factory") == "classic" {
+	jsxImportSourcePragma := GetPragmaFromSourceFile(file, "jsximportsource")
+	jsxRuntimePragma := GetPragmaFromSourceFile(file, "jsxruntime")
+	if GetPragmaArgument(jsxRuntimePragma, "factory") == "classic" {
 		return ""
 	}
 	if compilerOptions.Jsx == core.JsxEmitReactJSX ||
 		compilerOptions.Jsx == core.JsxEmitReactJSXDev ||
 		compilerOptions.JsxImportSource != "" ||
 		jsxImportSourcePragma != nil ||
-		getPragmaArgument(jsxRuntimePragma, "factory") == "automatic" {
-		result := getPragmaArgument(jsxImportSourcePragma, "factory")
+		GetPragmaArgument(jsxRuntimePragma, "factory") == "automatic" {
+		result := GetPragmaArgument(jsxImportSourcePragma, "factory")
 		if result == "" {
 			result = compilerOptions.JsxImportSource
 		}
@@ -2631,18 +2631,19 @@ func GetJSXRuntimeImport(base string, options *core.CompilerOptions) string {
 	return base + "/" + core.IfElse(options.Jsx == core.JsxEmitReactJSXDev, "jsx-dev-runtime", "jsx-runtime")
 }
 
-func getPragmaFromSourceFile(file *SourceFile, name string) *Pragma {
+func GetPragmaFromSourceFile(file *SourceFile, name string) *Pragma {
+	var result *Pragma
 	if file != nil {
 		for i := range file.Pragmas {
 			if file.Pragmas[i].Name == name {
-				return &file.Pragmas[i]
+				result = &file.Pragmas[i] // Last one wins
 			}
 		}
 	}
-	return nil
+	return result
 }
 
-func getPragmaArgument(pragma *Pragma, name string) string {
+func GetPragmaArgument(pragma *Pragma, name string) string {
 	if pragma != nil {
 		if arg, ok := pragma.Args[name]; ok {
 			return arg.Value

internal/binder/binder.go

@@ -324,7 +324,7 @@ func (b *Binder) getDeclarationName(node *ast.Node) string {
 			}
 			return GetSymbolNameForPrivateIdentifier(containingClass.Symbol(), name.Text())
 		}
-		if ast.IsPropertyNameLiteral(name) {
+		if ast.IsPropertyNameLiteral(name) || ast.IsJsxNamespacedName(name) {
 			return name.Text()
 		}
 		if ast.IsComputedPropertyName(name) {
@@ -339,9 +339,6 @@ func (b *Binder) getDeclarationName(node *ast.Node) string {
 			}
 			panic("Only computed properties with literal names have declaration names")
 		}
-		// if isJsxNamespacedName(name) {
-		// 	return getEscapedTextOfJsxNamespacedName(name)
-		// }
 		return ast.InternalSymbolNameMissing
 	}
 	switch node.Kind {

internal/checker/checker.go

@@ -2208,6 +2208,8 @@ func (c *Checker) checkSourceElementWorker(node *ast.Node) {
 		c.checkGrammarStatementInAmbientContext(node)
 	case ast.KindMissingDeclaration:
 		c.checkMissingDeclaration(node)
+	case ast.KindJSDocNonNullableType, ast.KindJSDocNullableType, ast.KindJSDocAllType, ast.KindJSDocTypeLiteral:
+		c.checkJSDocType(node)
 	}
 }
 
@@ -2326,6 +2328,30 @@ func (c *Checker) resolveJSDocMemberName(name *ast.Node, location *ast.Node) *as
 	return nil
 }
 
+func (c *Checker) checkJSDocType(node *ast.Node) {
+	c.checkJSDocTypeIsInJsFile(node)
+	node.ForEachChild(c.checkSourceElement)
+}
+
+func (c *Checker) checkJSDocTypeIsInJsFile(node *ast.Node) {
+	if !ast.IsInJSFile(node) {
+		if ast.IsJSDocNonNullableType(node) || ast.IsJSDocNullableType(node) {
+			token := core.IfElse(ast.IsJSDocNonNullableType(node), "!", "?")
+			postfix := node.Pos() == node.Type().Pos()
+			message := core.IfElse(postfix,
+				diagnostics.X_0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1,
+				diagnostics.X_0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1)
+			t := c.getTypeFromTypeNode(node.Type())
+			if ast.IsJSDocNullableType(node) && t != c.neverType && t != c.voidType {
+				t = c.getNullableType(t, core.IfElse(postfix, TypeFlagsUndefined, TypeFlagsNullable))
+			}
+			c.grammarErrorOnNode(node, message, token, c.TypeToString(t))
+		} else {
+			c.grammarErrorOnNode(node, diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments)
+		}
+	}
+}
+
 func (c *Checker) checkTypeParameter(node *ast.Node) {
 	// Grammar Checking
 	c.checkGrammarModifiers(node)
@@ -6598,7 +6624,7 @@ func (c *Checker) checkUnusedLocalsAndParameters(node *ast.Node) {
 					importClauses[importClause] = append(importClauses[importClause], declaration)
 				}
 			default:
-				if !ast.IsAmbientModule(declaration) {
+				if !ast.IsTypeParameterDeclaration(declaration) && !ast.IsAmbientModule(declaration) {
 					c.reportUnusedLocal(declaration, ast.SymbolName(local))
 				}
 			}

internal/checker/jsx.go

@@ -103,7 +103,7 @@ func (c *Checker) checkJsxFragment(node *ast.Node) *Type {
 	// by default, jsx:'react' will use jsxFactory = React.createElement and jsxFragmentFactory = React.Fragment
 	// if jsxFactory compiler option is provided, ensure jsxFragmentFactory compiler option or @jsxFrag pragma is provided too
 	nodeSourceFile := ast.GetSourceFileOfNode(node)
-	if c.compilerOptions.GetJSXTransformEnabled() && (c.compilerOptions.JsxFactory != "" || getPragmaFromSourceFile(nodeSourceFile, "jsx") != nil) && c.compilerOptions.JsxFragmentFactory == "" && getPragmaFromSourceFile(nodeSourceFile, "jsxfrag") == nil {
+	if c.compilerOptions.GetJSXTransformEnabled() && (c.compilerOptions.JsxFactory != "" || ast.GetPragmaFromSourceFile(nodeSourceFile, "jsx") != nil) && c.compilerOptions.JsxFragmentFactory == "" && ast.GetPragmaFromSourceFile(nodeSourceFile, "jsxfrag") == nil {
 		message := core.IfElse(c.compilerOptions.JsxFactory != "",
 			diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option,
 			diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments)
@@ -377,10 +377,10 @@ func (c *Checker) resolveJsxOpeningLikeElement(node *ast.Node, candidatesOutArra
 		result := c.getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node)
 		fakeSignature := c.createSignatureForJSXIntrinsic(node, result)
 		c.checkTypeAssignableToAndOptionallyElaborate(c.checkExpressionWithContextualType(node.Attributes(), c.getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), nil /*inferenceContext*/, CheckModeNormal), result, node.TagName(), node.Attributes(), nil, nil)
-		typeArgumentList := node.TypeArgumentList()
-		if typeArgumentList != nil {
-			c.checkSourceElements(typeArgumentList.Nodes)
-			c.diagnostics.Add(ast.NewDiagnostic(ast.GetSourceFileOfNode(node), node.TypeArgumentList().Loc, diagnostics.Expected_0_type_arguments_but_got_1, 0, len(typeArgumentList.Nodes)))
+		typeArguments := node.TypeArguments()
+		if len(typeArguments) != 0 {
+			c.checkSourceElements(typeArguments)
+			c.diagnostics.Add(ast.NewDiagnostic(ast.GetSourceFileOfNode(node), node.TypeArgumentList().Loc, diagnostics.Expected_0_type_arguments_but_got_1, 0, len(typeArguments)))
 		}
 		return fakeSignature
 	}
@@ -1134,7 +1134,7 @@ func (c *Checker) getJsxNamespace(location *ast.Node) string {
 				if links.localJsxFragmentNamespace != "" {
 					return links.localJsxFragmentNamespace
 				}
-				jsxFragmentPragma := getPragmaFromSourceFile(file, "jsxfrag")
+				jsxFragmentPragma := ast.GetPragmaFromSourceFile(file, "jsxfrag")
 				if jsxFragmentPragma != nil {
 					links.localJsxFragmentFactory = c.parseIsolatedEntityName(jsxFragmentPragma.Args["factory"].Value)
 					if links.localJsxFragmentFactory != nil {
@@ -1179,7 +1179,7 @@ func (c *Checker) getLocalJsxNamespace(file *ast.SourceFile) string {
 	if links.localJsxNamespace != "" {
 		return links.localJsxNamespace
 	}
-	jsxPragma := getPragmaFromSourceFile(file, "jsx")
+	jsxPragma := ast.GetPragmaFromSourceFile(file, "jsx")
 	if jsxPragma != nil {
 		links.localJsxFactory = c.parseIsolatedEntityName(jsxPragma.Args["factory"].Value)
 		if links.localJsxFactory != nil {
@@ -1208,7 +1208,7 @@ func (c *Checker) getJsxFragmentFactoryEntity(location *ast.Node) *ast.EntityNam
 			if links.localJsxFragmentFactory != nil {
 				return links.localJsxFragmentFactory
 			}
-			jsxFragPragma := getPragmaFromSourceFile(file, "jsxfrag")
+			jsxFragPragma := ast.GetPragmaFromSourceFile(file, "jsxfrag")
 			if jsxFragPragma != nil {
 				links.localJsxFragmentFactory = c.parseIsolatedEntityName(jsxFragPragma.Args["factory"].Value)
 				return links.localJsxFragmentFactory
@@ -1246,7 +1246,6 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node)
 	if links != nil && links.jsxImplicitImportContainer != nil {
 		return core.IfElse(links.jsxImplicitImportContainer == c.unknownSymbol, nil, links.jsxImplicitImportContainer)
 	}
-
 	moduleReference, specifier := c.getJSXRuntimeImportSpecifier(file)
 	if moduleReference == "" {
 		return nil
@@ -1266,23 +1265,3 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node)
 func (c *Checker) getJSXRuntimeImportSpecifier(file *ast.SourceFile) (moduleReference string, specifier *ast.Node) {
 	return c.program.GetJSXRuntimeImportSpecifier(file.Path())
 }
-
-func getPragmaFromSourceFile(file *ast.SourceFile, name string) *ast.Pragma {
-	if file != nil {
-		for i := range file.Pragmas {
-			if file.Pragmas[i].Name == name {
-				return &file.Pragmas[i]
-			}
-		}
-	}
-	return nil
-}
-
-func getPragmaArgument(pragma *ast.Pragma, name string) string {
-	if pragma != nil {
-		if arg, ok := pragma.Args[name]; ok {
-			return arg.Value
-		}
-	}
-	return ""
-}

internal/parser/parser.go

@@ -2588,6 +2588,18 @@ func (p *Parser) parsePostfixTypeOrHigher() *ast.Node {
 	typeNode := p.parseNonArrayType()
 	for !p.hasPrecedingLineBreak() {
 		switch p.token {
+		case ast.KindExclamationToken:
+			p.nextToken()
+			typeNode = p.factory.NewJSDocNonNullableType(typeNode)
+			p.finishNode(typeNode, pos)
+		case ast.KindQuestionToken:
+			// If next token is start of a type we have a conditional type
+			if p.lookAhead((*Parser).nextIsStartOfType) {
+				return typeNode
+			}
+			p.nextToken()
+			typeNode = p.factory.NewJSDocNullableType(typeNode)
+			p.finishNode(typeNode, pos)
 		case ast.KindOpenBracketToken:
 			p.parseExpected(ast.KindOpenBracketToken)
 			if p.isStartOfType(false /*isStartOfParameter*/) {
@@ -3553,11 +3565,11 @@ func (p *Parser) parseTupleElementType() *ast.TypeNode {
 		return result
 	}
 	typeNode := p.parseType()
-	// If next token is start of a type we have a conditional type and not an optional type
-	if p.token == ast.KindQuestionToken && !p.lookAhead((*Parser).nextIsStartOfType) {
-		p.nextToken()
-		typeNode = p.factory.NewOptionalTypeNode(typeNode)
-		p.finishNode(typeNode, pos)
+	if ast.IsJSDocNullableType(typeNode) && typeNode.Pos() == typeNode.Type().Pos() {
+		node := p.factory.NewOptionalTypeNode(typeNode.Type())
+		node.Flags = typeNode.Flags
+		node.Loc = typeNode.Loc
+		return node
 	}
 	return typeNode
 }
@@ -5001,12 +5013,11 @@ func (p *Parser) parseSimpleUnaryExpression() *ast.Expression {
 	case ast.KindVoidKeyword:
 		return p.parseVoidExpression()
 	case ast.KindLessThanToken:
-		// !!!
-		// // Just like in parseUpdateExpression, we need to avoid parsing type assertions when
-		// // in JSX and we see an expression like "+ <foo> bar".
-		// if (languageVariant == core.LanguageVariant.JSX) {
-		// 	return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true, /*topInvalidNodePosition*/ undefined, /*openingTag*/ undefined, /*mustBeUnary*/ true);
-		// }
+		// Just like in parseUpdateExpression, we need to avoid parsing type assertions when
+		// in JSX and we see an expression like "+ <foo> bar".
+		if p.languageVariant == core.LanguageVariantJSX {
+			return p.parseJsxElementOrSelfClosingElementOrFragment(true /*inExpressionContext*/, -1 /*topInvalidNodePosition*/, nil /*openingTag*/, true /*mustBeUnary*/)
+		}
 		// // This is modified UnaryExpression grammar in TypeScript
 		// //  UnaryExpression (modified):
 		// //      < type > UnaryExpression
@@ -6415,7 +6426,7 @@ func getCommentPragmas(f *ast.NodeFactory, sourceText string) (pragmas []ast.Pra
 }
 
 func extractPragmas(commentRange ast.CommentRange, text string) []ast.Pragma {
-	if commentRange.Kind == ast.KindSingleLineCommentTrivia && match(text, 0, "//") {
+	if commentRange.Kind == ast.KindSingleLineCommentTrivia {
 		pos := 2
 		tripleSlash := match(text, pos, "/")
 		if tripleSlash {
@@ -6473,6 +6484,7 @@ func extractPragmas(commentRange ast.CommentRange, text string) []ast.Pragma {
 		}
 	}
 	if commentRange.Kind == ast.KindMultiLineCommentTrivia {
+		text = text[:len(text)-2]
 		pos := 2
 		var pragmas []ast.Pragma
 		for {
@@ -6613,7 +6625,6 @@ func (p *Parser) processPragmasIntoFields(context *ast.SourceFile) {
 					}
 				}
 			}
-
 		case "jsx", "jsxfrag", "jsximportsource", "jsxruntime":
 			// Nothing to do here
 		default:

internal/scanner/scanner.go

@@ -1012,7 +1012,6 @@ func (s *Scanner) ReScanSlashToken() ast.Kind {
 			switch {
 			case size == 0 || stringutil.IsLineBreak(ch):
 				s.tokenFlags |= ast.TokenFlagsUnterminated
-				s.error(diagnostics.Unterminated_regular_expression_literal)
 				break loop
 			case inEscape:
 				// Parsing an escape character;