Add types baselines (microsoft#296)

Author: gabritto

internal/ast/ast.go

@@ -587,6 +587,18 @@ func (n *Node) Comments() []*Node {
 	panic("Unhandled case in Node.Comments: " + n.Kind.String())
 }
 
+func (n *Node) Label() *Node {
+	switch n.Kind {
+	case KindLabeledStatement:
+		return n.AsLabeledStatement().Label
+	case KindBreakStatement:
+		return n.AsBreakStatement().Label
+	case KindContinueStatement:
+		return n.AsContinueStatement().Label
+	}
+	panic("Unhandled case in Node.Label: " + n.Kind.String())
+}
+
 // Node casts
 
 func (n *Node) AsIdentifier() *Identifier {
@@ -2351,6 +2363,10 @@ func (node *LabeledStatement) VisitEachChild(v *NodeVisitor) *Node {
 	return v.Factory.UpdateLabeledStatement(node, v.visitNode(node.Label), v.visitNode(node.Statement))
 }
 
+func IsLabeledStatement(node *Node) bool {
+	return node.Kind == KindLabeledStatement
+}
+
 // ExpressionStatement
 
 type ExpressionStatement struct {
@@ -6572,6 +6588,10 @@ func (node *JsxSpreadAttribute) VisitEachChild(v *NodeVisitor) *Node {
 	return v.Factory.UpdateJsxSpreadAttribute(node, v.visitNode(node.Expression))
 }
 
+func IsJsxClosingElement(node *Node) bool {
+	return node.Kind == KindJsxClosingElement
+}
+
 // JsxExpression
 
 type JsxExpression struct {

internal/ast/utilities.go

@@ -1859,6 +1859,104 @@ func IsBlockScope(node *Node, parentNode *Node) bool {
 	return false
 }
 
+type SemanticMeaning int32
+
+const (
+	SemanticMeaningNone      SemanticMeaning = 0
+	SemanticMeaningValue     SemanticMeaning = 1 << 0
+	SemanticMeaningType      SemanticMeaning = 1 << 1
+	SemanticMeaningNamespace SemanticMeaning = 1 << 2
+	SemanticMeaningAll       SemanticMeaning = SemanticMeaningValue | SemanticMeaningType | SemanticMeaningNamespace
+)
+
+func GetMeaningFromDeclaration(node *Node) SemanticMeaning {
+	switch node.Kind {
+	case KindVariableDeclaration:
+		return SemanticMeaningValue
+	case KindParameter,
+		KindBindingElement,
+		KindPropertyDeclaration,
+		KindPropertySignature,
+		KindPropertyAssignment,
+		KindShorthandPropertyAssignment,
+		KindMethodDeclaration,
+		KindMethodSignature,
+		KindConstructor,
+		KindGetAccessor,
+		KindSetAccessor,
+		KindFunctionDeclaration,
+		KindFunctionExpression,
+		KindArrowFunction,
+		KindCatchClause,
+		KindJsxAttribute:
+		return SemanticMeaningValue
+
+	case KindTypeParameter,
+		KindInterfaceDeclaration,
+		KindTypeAliasDeclaration,
+		KindTypeLiteral:
+		return SemanticMeaningType
+	case KindEnumMember, KindClassDeclaration:
+		return SemanticMeaningValue | SemanticMeaningType
+
+	case KindModuleDeclaration:
+		if IsAmbientModule(node) {
+			return SemanticMeaningNamespace | SemanticMeaningValue
+		} else if GetModuleInstanceState(node) == ModuleInstanceStateInstantiated {
+			return SemanticMeaningNamespace | SemanticMeaningValue
+		} else {
+			return SemanticMeaningNamespace
+		}
+
+	case KindEnumDeclaration,
+		KindNamedImports,
+		KindImportSpecifier,
+		KindImportEqualsDeclaration,
+		KindImportDeclaration,
+		KindExportAssignment,
+		KindExportDeclaration:
+		return SemanticMeaningAll
+
+	// An external module can be a Value
+	case KindSourceFile:
+		return SemanticMeaningNamespace | SemanticMeaningValue
+	}
+
+	return SemanticMeaningAll
+}
+
+func IsPropertyAccessOrQualifiedName(node *Node) bool {
+	return node.Kind == KindPropertyAccessExpression || node.Kind == KindQualifiedName
+}
+
+func IsLabelName(node *Node) bool {
+	return IsLabelOfLabeledStatement(node) || IsJumpStatementTarget(node)
+}
+
+func IsLabelOfLabeledStatement(node *Node) bool {
+	if !IsIdentifier(node) {
+		return false
+	}
+	if !IsLabeledStatement(node.Parent) {
+		return false
+	}
+	return node == node.Parent.Label()
+}
+
+func IsJumpStatementTarget(node *Node) bool {
+	if !IsIdentifier(node) {
+		return false
+	}
+	if !IsBreakOrContinueStatement(node.Parent) {
+		return false
+	}
+	return node == node.Parent.Label()
+}
+
+func IsBreakOrContinueStatement(node *Node) bool {
+	return NodeKindIs(node, KindBreakStatement, KindContinueStatement)
+}
+
 // GetModuleInstanceState is used during binding as well as in transformations and tests, and therefore may be invoked
 // with a node that does not yet have its `Parent` pointer set. In this case, an `ancestors` represents a stack of
 // virtual `Parent` pointers that can be used to walk up the tree. Since `getModuleInstanceStateForAliasTarget` may

internal/binder/binder.go

@@ -69,15 +69,6 @@ type Binder struct {
 	singleDeclarationsPool core.Pool[*ast.Node]
 }
 
-type ModuleInstanceState int32
-
-const (
-	ModuleInstanceStateUnknown ModuleInstanceState = iota
-	ModuleInstanceStateNonInstantiated
-	ModuleInstanceStateInstantiated
-	ModuleInstanceStateConstEnumOnly
-)
-
 type ActiveLabel struct {
 	next           *ActiveLabel
 	breakTarget    *ast.FlowLabel
@@ -2684,18 +2675,6 @@ func getPostfixTokenFromNode(node *ast.Node) *ast.Node {
 	panic("Unhandled case in getPostfixTokenFromNode")
 }
 
-func nodeHasName(statement *ast.Node, id *ast.Node) bool {
-	name := statement.Name()
-	if name != nil {
-		return ast.IsIdentifier(name) && name.AsIdentifier().Text == id.AsIdentifier().Text
-	}
-	if ast.IsVariableStatement(statement) {
-		declarations := statement.AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes
-		return core.Some(declarations, func(d *ast.Node) bool { return nodeHasName(d, id) })
-	}
-	return false
-}
-
 func isAsyncFunction(node *ast.Node) bool {
 	switch node.Kind {
 	case ast.KindFunctionDeclaration, ast.KindFunctionExpression, ast.KindArrowFunction, ast.KindMethodDeclaration: