More fixes (microsoft#729)

Author: ahejlsberg

internal/ast/ast.go

@@ -2164,6 +2164,10 @@ func (node *IfStatement) computeSubtreeFacts() SubtreeFacts {
 		propagateSubtreeFacts(node.ElseStatement)
 }
 
+func IsIfStatement(node *Node) bool {
+	return node.Kind == KindIfStatement
+}
+
 // DoStatement
 
 type DoStatement struct {

internal/ast/tokenflags.go

@@ -23,8 +23,9 @@ const (
 	TokenFlagsSingleQuote                    TokenFlags = 1 << 16 // e.g. `'abc'`
 	TokenFlagsBinaryOrOctalSpecifier         TokenFlags = TokenFlagsBinarySpecifier | TokenFlagsOctalSpecifier
 	TokenFlagsWithSpecifier                  TokenFlags = TokenFlagsHexSpecifier | TokenFlagsBinaryOrOctalSpecifier
-	TokenFlagsStringLiteralFlags             TokenFlags = TokenFlagsHexEscape | TokenFlagsUnicodeEscape | TokenFlagsExtendedUnicodeEscape | TokenFlagsContainsInvalidEscape | TokenFlagsSingleQuote
+	TokenFlagsStringLiteralFlags             TokenFlags = TokenFlagsUnterminated | TokenFlagsHexEscape | TokenFlagsUnicodeEscape | TokenFlagsExtendedUnicodeEscape | TokenFlagsContainsInvalidEscape | TokenFlagsSingleQuote
 	TokenFlagsNumericLiteralFlags            TokenFlags = TokenFlagsScientific | TokenFlagsOctal | TokenFlagsContainsLeadingZero | TokenFlagsWithSpecifier | TokenFlagsContainsSeparator | TokenFlagsContainsInvalidSeparator
-	TokenFlagsTemplateLiteralLikeFlags       TokenFlags = TokenFlagsHexEscape | TokenFlagsUnicodeEscape | TokenFlagsExtendedUnicodeEscape | TokenFlagsContainsInvalidEscape
+	TokenFlagsTemplateLiteralLikeFlags       TokenFlags = TokenFlagsUnterminated | TokenFlagsHexEscape | TokenFlagsUnicodeEscape | TokenFlagsExtendedUnicodeEscape | TokenFlagsContainsInvalidEscape
+	TokenFlagsRegularExpressionLiteralFlags  TokenFlags = TokenFlagsUnterminated
 	TokenFlagsIsInvalid                      TokenFlags = TokenFlagsOctal | TokenFlagsContainsLeadingZero | TokenFlagsContainsInvalidSeparator | TokenFlagsContainsInvalidEscape
 )

internal/ast/utilities.go

@@ -2571,3 +2571,7 @@ func IsRequireCall(node *Node, requireStringLiteralLikeArgument bool) bool {
 	}
 	return !requireStringLiteralLikeArgument || IsStringLiteralLike(call.Arguments.Nodes[0])
 }
+
+func IsUnterminatedLiteral(node *Node) bool {
+	return node.LiteralLikeData().TokenFlags&TokenFlagsUnterminated != 0
+}

internal/binder/binder.go

@@ -66,6 +66,7 @@ type Binder struct {
 	hasFlowEffects         bool
 	inStrictMode           bool
 	inAssignmentPattern    bool
+	seenParseError         bool
 	symbolCount            int
 	classifiableNames      core.Set[string]
 	symbolPool             core.Pool[ast.Symbol]
@@ -713,16 +714,23 @@ func (b *Binder) bind(node *ast.Node) bool {
 	// the current 'container' node when it changes. This helps us know which symbol table
 	// a local should go into for example. Since terminal nodes are known not to have
 	// children, as an optimization we don't process those.
+	thisNodeOrAnySubnodesHasError := node.Flags&ast.NodeFlagsThisNodeHasError != 0
 	if node.Kind > ast.KindLastToken {
 		saveParent := b.parent
+		saveSeenParseError := b.seenParseError
 		b.parent = node
+		b.seenParseError = false
 		containerFlags := GetContainerFlags(node)
 		if containerFlags == ContainerFlagsNone {
 			b.bindChildren(node)
 		} else {
 			b.bindContainer(node, containerFlags)
 		}
+		if b.seenParseError {
+			thisNodeOrAnySubnodesHasError = true
+		}
 		b.parent = saveParent
+		b.seenParseError = saveSeenParseError
 	} else {
 		saveParent := b.parent
 		if node.Kind == ast.KindEndOfFile {
@@ -731,6 +739,10 @@ func (b *Binder) bind(node *ast.Node) bool {
 		b.bindJSDoc(node)
 		b.parent = saveParent
 	}
+	if thisNodeOrAnySubnodesHasError {
+		node.Flags |= ast.NodeFlagsThisNodeOrAnySubNodesHasError
+		b.seenParseError = true
+	}
 	b.inStrictMode = saveInStrictMode
 	return false
 }

internal/binder/nameresolver.go

@@ -489,7 +489,7 @@ func isTypeParameterSymbolDeclaredInContainer(symbol *ast.Symbol, container *ast
 func isSelfReferenceLocation(node *ast.Node, lastLocation *ast.Node) bool {
 	switch node.Kind {
 	case ast.KindParameter:
-		return lastLocation != nil && lastLocation == node.AsParameterDeclaration().Name()
+		return lastLocation != nil && lastLocation == node.Name()
 	case ast.KindFunctionDeclaration, ast.KindClassDeclaration, ast.KindInterfaceDeclaration, ast.KindEnumDeclaration,
 		ast.KindTypeAliasDeclaration, ast.KindModuleDeclaration: // For `namespace N { N; }`
 		return true

internal/checker/checker.go

@@ -1785,7 +1785,7 @@ func (c *Checker) isConstantReference(node *ast.Node) bool {
 	case ast.KindPropertyAccessExpression, ast.KindElementAccessExpression:
 		// The resolvedSymbol property is initialized by checkPropertyAccess or checkElementAccess before we get here.
 		if c.isConstantReference(node.Expression()) {
-			symbol := c.typeNodeLinks.Get(node).resolvedSymbol
+			symbol := c.getResolvedSymbolOrNil(node)
 			if symbol != nil {
 				return c.isReadonlySymbol(symbol)
 			}

internal/checker/flow.go

@@ -320,10 +320,13 @@ type NodeLinks struct {
 	hasReportedStatementInAmbientContext bool           // Cache boolean if we report statements in ambient context
 }
 
+type SymbolNodeLinks struct {
+	resolvedSymbol *ast.Symbol // Resolved symbol associated with node
+}
+
 type TypeNodeLinks struct {
-	resolvedType        *Type       // Cached type of type node
-	resolvedSymbol      *ast.Symbol // Cached name resolution result
-	outerTypeParameters []*Type     // Outer type parameters of anonymous object type
+	resolvedType        *Type   // Resolved type associated with node
+	outerTypeParameters []*Type // Outer type parameters of anonymous object type
 }
 
 // Links for enum members

internal/checker/types.go

@@ -151,5 +151,20 @@ func AnyToString(v any) string {
 	case jsnum.PseudoBigInt:
 		return v.String()
 	}
-	panic("Unhandled case in anyToString")
+	panic("Unhandled case in AnyToString")
+}
+
+func IsTruthy(v any) bool {
+	// !!! This function should behave identically to the expression `!!v` in JS
+	switch v := v.(type) {
+	case string:
+		return len(v) != 0
+	case jsnum.Number:
+		return v != 0 && !v.IsNaN()
+	case bool:
+		return v
+	case jsnum.PseudoBigInt:
+		return v != jsnum.PseudoBigInt{}
+	}
+	panic("Unhandled case in IsTruthy")
 }

internal/evaluator/evaluator.go

@@ -125,6 +125,7 @@ func (p *Parser) parseJSDocComment(parent *ast.Node, start int, end int, fullSta
 	saveParsingMode := p.scanner.JSDocParsingMode
 	saveScannerState := p.scanner.Mark()
 	saveDiagnosticsLength := len(p.diagnostics)
+	saveHasParseError := p.hasParseError
 
 	// initial indent is start+4 to account for leading `/** `
 	// + 1 because \n is one character before the first character in the line and,
@@ -153,6 +154,7 @@ func (p *Parser) parseJSDocComment(parent *ast.Node, start int, end int, fullSta
 	p.scanner.JSDocParsingMode = saveParsingMode
 	p.scanner.Rewind(saveScannerState)
 	p.token = saveToken
+	p.hasParseError = saveHasParseError
 
 	return comment
 }