Add symbol baseliner (#191)

gabritto · jakebailey · web-flow · commit 07a5e0475b42 · 2025-01-08T03:16:04.000Z
Co-authored-by: Jake Bailey &lt;5341706+jakebailey@users.noreply.github.com&gt;
diff --git a/internal/ast/utilities.go b/internal/ast/utilities.go
@@ -1123,7 +1123,7 @@ func IsDeclaration(node *Node) bool {
 
 // True if `name` is the name of a declaration node
 func IsDeclarationName(name *Node) bool {
-	return !IsSourceFile(name) && !IsBindingPattern(name) && IsDeclaration(name.Parent)
+	return !IsSourceFile(name) && !IsBindingPattern(name) && IsDeclaration(name.Parent) && name.Parent.Name() == name
 }
 
 // Like 'isDeclarationName', but returns true for LHS of `import { x as y }` or `export { x as y }`.
diff --git a/internal/compiler/checker.go b/internal/compiler/checker.go
@@ -8073,7 +8073,7 @@ func (c *Checker) isInPropertyInitializerOrClassStaticBlock(node *ast.Node) bool
 			}
 			return ast.FindAncestorQuit
 		default:
-			if isExpressionNode(node) {
+			if IsExpressionNode(node) {
 				return ast.FindAncestorFalse
 			}
 			return ast.FindAncestorQuit
@@ -22736,6 +22736,14 @@ func (c *Checker) getActualTypeVariable(t *Type) *Type {
 	return t
 }
 
+func (c *Checker) GetSymbolAtLocation(node *ast.Node) *ast.Symbol {
+	// !!!
+	// const node = getParseTreeNode(nodeIn);
+
+	// set ignoreErrors: true because any lookups invoked by the API shouldn't cause any new errors
+	return c.getSymbolAtLocation(node, true /*ignoreErrors*/)
+}
+
 func (c *Checker) getSymbolAtLocation(node *ast.Node, ignoreErrors bool) *ast.Symbol {
 	if ast.IsSourceFile(node) {
 		if ast.IsExternalModule(node.AsSourceFile()) {
@@ -22963,7 +22971,7 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast
 		}
 	}
 
-	if isExpressionNode(name) {
+	if IsExpressionNode(name) {
 		if ast.NodeIsMissing(name) {
 			// Missing entity name.
 			return nil
@@ -23066,7 +23074,7 @@ func (c *Checker) getTypeOfNode(node *ast.Node) *Type {
 		return typeFromTypeNode
 	}
 
-	if isExpressionNode(node) {
+	if IsExpressionNode(node) {
 		return c.getRegularTypeOfExpression(node)
 	}
 
diff --git a/internal/compiler/checker_test.go b/internal/compiler/checker_test.go
@@ -33,14 +33,14 @@ foo.bar;`
 	}
 	p := NewProgram(opts)
 	p.bindSourceFiles()
-	c := p.getTypeChecker()
+	c := p.GetTypeChecker()
 	file := p.filesByPath["/foo.ts"]
 	interfaceId := file.Statements.Nodes[0].Name()
 	varId := file.Statements.Nodes[1].AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes[0].Name()
 	propAccess := file.Statements.Nodes[2].AsExpressionStatement().Expression
 	nodes := []*ast.Node{interfaceId, varId, propAccess}
 	for _, node := range nodes {
-		symbol := c.getSymbolAtLocation(node, true /*ignoreErrors*/)
+		symbol := c.GetSymbolAtLocation(node)
 		if symbol == nil {
 			t.Fatalf("Expected symbol to be non-nil")
 		}
diff --git a/internal/compiler/grammarchecks.go b/internal/compiler/grammarchecks.go
@@ -97,7 +97,7 @@ func (c *Checker) checkGrammarPrivateIdentifierExpression(privId *ast.PrivateIde
 	}
 
 	if !ast.IsForInStatement(privId.Parent) {
-		if !isExpressionNode(privIdAsNode) {
+		if !IsExpressionNode(privIdAsNode) {
 			return c.grammarErrorOnNode(privIdAsNode, diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression)
 		}
 
diff --git a/internal/compiler/printer.go b/internal/compiler/printer.go
@@ -27,6 +27,10 @@ func (c *Checker) getTypePrecedence(t *Type) ast.TypePrecedence {
 	return ast.TypePrecedenceNonArray
 }
 
+func (c *Checker) SymbolToString(s *ast.Symbol) string {
+	return c.symbolToString(s)
+}
+
 func (c *Checker) symbolToString(s *ast.Symbol) string {
 	if s.ValueDeclaration != nil {
 		name := ast.GetNameOfDeclaration(s.ValueDeclaration)
@@ -571,7 +575,7 @@ func (c *Checker) getTextAndTypeOfNode(node *ast.Node) (string, *Type, bool) {
 			}
 		}
 	}
-	if isExpressionNode(node) && !isRightSideOfQualifiedNameOrPropertyAccess(node) {
+	if IsExpressionNode(node) && !isRightSideOfQualifiedNameOrPropertyAccess(node) {
 		return scanner.GetTextOfNode(node), c.getTypeOfExpression(node), false
 	}
 	return "", nil, false
diff --git a/internal/compiler/program.go b/internal/compiler/program.go
@@ -360,7 +360,7 @@ func (p *Program) GetSemanticDiagnostics(sourceFile *ast.SourceFile) []*ast.Diag
 }
 
 func (p *Program) GetGlobalDiagnostics() []*ast.Diagnostic {
-	return sortAndDeduplicateDiagnostics(p.getTypeChecker().GetGlobalDiagnostics())
+	return sortAndDeduplicateDiagnostics(p.GetTypeChecker().GetGlobalDiagnostics())
 }
 
 func (p *Program) TypeCount() int {
@@ -370,7 +370,7 @@ func (p *Program) TypeCount() int {
 	return int(p.checker.typeCount)
 }
 
-func (p *Program) getTypeChecker() *Checker {
+func (p *Program) GetTypeChecker() *Checker {
 	if p.checker == nil {
 		p.checker = NewChecker(p)
 	}
@@ -386,7 +386,7 @@ func (p *Program) getBindDiagnosticsForFile(sourceFile *ast.SourceFile) []*ast.D
 }
 
 func (p *Program) getSemanticDiagnosticsForFile(sourceFile *ast.SourceFile) []*ast.Diagnostic {
-	return core.Concatenate(sourceFile.BindDiagnostics(), p.getTypeChecker().GetDiagnostics(sourceFile))
+	return core.Concatenate(sourceFile.BindDiagnostics(), p.GetTypeChecker().GetDiagnostics(sourceFile))
 }
 
 func (p *Program) getDiagnosticsHelper(sourceFile *ast.SourceFile, ensureBound bool, getDiagnostics func(*ast.SourceFile) []*ast.Diagnostic) []*ast.Diagnostic {
@@ -414,7 +414,7 @@ type NodeCount struct {
 func (p *Program) PrintSourceFileWithTypes() {
 	for _, file := range p.files {
 		if tspath.GetBaseFileName(file.FileName()) == "main.ts" {
-			fmt.Print(p.getTypeChecker().sourceFileWithTypes(file))
+			fmt.Print(p.GetTypeChecker().sourceFileWithTypes(file))
 		}
 	}
 }
@@ -785,3 +785,8 @@ func (p *Program) Emit(options *EmitOptions) *EmitResult {
 	}
 	return result
 }
+
+func (p *Program) GetSourceFile(filename string) *ast.SourceFile {
+	path := tspath.ToPath(filename, p.host.GetCurrentDirectory(), p.host.FS().UseCaseSensitiveFileNames())
+	return p.filesByPath[path]
+}
diff --git a/internal/compiler/utilities.go b/internal/compiler/utilities.go
@@ -993,7 +993,7 @@ func isValidTypeOnlyAliasUseSite(useSite *ast.Node) bool {
 		ast.IsPartOfTypeQuery(useSite) ||
 		isIdentifierInNonEmittingHeritageClause(useSite) ||
 		isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) ||
-		!(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite))
+		!(IsExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite))
 }
 
 func isIdentifierInNonEmittingHeritageClause(node *ast.Node) bool {
@@ -1062,7 +1062,7 @@ func nodeCanBeDecorated(useLegacyDecorators bool, node *ast.Node, parent *ast.No
 	return false
 }
 
-func isExpressionNode(node *ast.Node) bool {
+func IsExpressionNode(node *ast.Node) bool {
 	switch node.Kind {
 	case ast.KindSuperKeyword, ast.KindNullKeyword, ast.KindTrueKeyword, ast.KindFalseKeyword, ast.KindRegularExpressionLiteral,
 		ast.KindArrayLiteralExpression, ast.KindObjectLiteralExpression, ast.KindPropertyAccessExpression, ast.KindElementAccessExpression,
@@ -1154,7 +1154,7 @@ func isInExpressionContext(node *ast.Node) bool {
 	case ast.KindSatisfiesExpression:
 		return parent.AsSatisfiesExpression().Expression == node
 	default:
-		return isExpressionNode(parent)
+		return IsExpressionNode(parent)
 	}
 }
 
diff --git a/internal/testutil/baseline/baseline.go b/internal/testutil/baseline/baseline.go
@@ -15,11 +15,11 @@ type Options struct {
 
 const NoContent = "<no content>"
 
-func Run(t testing.TB, fileName string, actual string, opts Options) {
+func Run(t *testing.T, fileName string, actual string, opts Options) {
 	writeComparison(t, actual, fileName, opts)
 }
 
-func writeComparison(t testing.TB, actual string, relativeFileName string, opts Options) {
+func writeComparison(t *testing.T, actual string, relativeFileName string, opts Options) {
 	if actual == "" {
 		panic("The generated content was \"\". Return 'baseline.NoContent' if no baselining is required.")
 	}
diff --git a/internal/testutil/baseline/error_baseline.go b/internal/testutil/baseline/error_baseline.go
@@ -19,12 +19,6 @@ import (
 // IO
 const harnessNewLine = "\r\n"
 
-var (
-	lineDelimiter = regexp.MustCompile("\r?\n")
-	nonWhitespace = regexp.MustCompile(`\S`)
-	tsExtension   = regexp.MustCompile(`\.tsx?$`)
-)
-
 var formatOpts = &compiler.DiagnosticsFormattingOptions{
 	NewLine: harnessNewLine,
 }
@@ -40,7 +34,7 @@ var (
 	diagnosticsLocationPattern = regexp.MustCompile(`(?i)(lib.*\.d\.ts):\d+:\d+`)
 )
 
-func DoErrorBaseline(t testing.TB, baselinePath string, inputFiles []*TestFile, errors []*ast.Diagnostic, pretty bool) {
+func DoErrorBaseline(t *testing.T, baselinePath string, inputFiles []*TestFile, errors []*ast.Diagnostic, pretty bool) {
 	baselinePath = tsExtension.ReplaceAllString(baselinePath, ".errors.txt")
 	var errorBaseline string
 	if len(errors) > 0 {
@@ -61,7 +55,7 @@ func minimalDiagnosticsToString(diagnostics []*ast.Diagnostic, pretty bool) stri
 	return output.String()
 }
 
-func getErrorBaseline(t testing.TB, inputFiles []*TestFile, diagnostics []*ast.Diagnostic, pretty bool) string {
+func getErrorBaseline(t *testing.T, inputFiles []*TestFile, diagnostics []*ast.Diagnostic, pretty bool) string {
 	t.Helper()
 	outputLines := iterateErrorBaseline(t, inputFiles, diagnostics, pretty)
 
@@ -77,7 +71,7 @@ func getErrorBaseline(t testing.TB, inputFiles []*TestFile, diagnostics []*ast.D
 	return strings.Join(outputLines, "")
 }
 
-func iterateErrorBaseline(t testing.TB, inputFiles []*TestFile, inputDiagnostics []*ast.Diagnostic, pretty bool) []string {
+func iterateErrorBaseline(t *testing.T, inputFiles []*TestFile, inputDiagnostics []*ast.Diagnostic, pretty bool) []string {
 	t.Helper()
 	diagnostics := slices.Clone(inputDiagnostics)
 	slices.SortFunc(diagnostics, compiler.CompareDiagnostics)
@@ -225,7 +219,6 @@ func iterateErrorBaseline(t testing.TB, inputFiles []*TestFile, inputDiagnostics
 		// Verify we didn't miss any errors in this file
 		assert.Check(t, cmp.Equal(markedErrorCount, len(fileErrors)), "count of errors in "+inputFile.unitName)
 		_, isDupe := dupeCase[sanitizeTestFilePath(inputFile.unitName)]
-		checkDuplicatedFileName(inputFile.unitName, dupeCase)
 		result = append(result, outputLines.String())
 		if isDupe {
 			// Case-duplicated files on a case-insensitive build will have errors reported in both the dupe and the original
@@ -253,19 +246,6 @@ func iterateErrorBaseline(t testing.TB, inputFiles []*TestFile, inputDiagnostics
 	return result
 }
 
-func checkDuplicatedFileName(resultName string, dupeCase map[string]int) string {
-	resultName = sanitizeTestFilePath(resultName)
-	if _, ok := dupeCase[resultName]; ok {
-		// A different baseline filename should be manufactured if the names differ only in case, for windows compat
-		count := 1 + dupeCase[resultName]
-		dupeCase[resultName] = count
-		resultName = fmt.Sprintf("%s.dupe%d", resultName, count)
-	} else {
-		dupeCase[resultName] = 0
-	}
-	return resultName
-}
-
 func flattenDiagnosticMessage(d *ast.Diagnostic, newLine string) string {
 	var output strings.Builder
 	compiler.WriteFlattenedDiagnosticMessage(&output, d, newLine)
diff --git a/internal/testutil/baseline/symbol_baseline.go b/internal/testutil/baseline/symbol_baseline.go
diff --git a/internal/testutil/baseline/util.go b/internal/testutil/baseline/util.go

Original file line number	Diff line number	Diff line change
`@@ -1123,7 +1123,7 @@ func IsDeclaration(node *Node) bool {`
`1123`	`1123`
`1124`	`1124`	// True if `name` is the name of a declaration node
`1125`	`1125`	`func IsDeclarationName(name *Node) bool {`
`1126`		`- return !IsSourceFile(name) && !IsBindingPattern(name) && IsDeclaration(name.Parent)`
	`1126`	`+ return !IsSourceFile(name) && !IsBindingPattern(name) && IsDeclaration(name.Parent) && name.Parent.Name() == name`
`1127`	`1127`	`}`
`1128`	`1128`
`1129`	`1129`	// Like 'isDeclarationName', but returns true for LHS of `import { x as y }` or `export { x as y }`.
Original file line number	Diff line number	Diff line change
`@@ -8073,7 +8073,7 @@ func (c Checker) isInPropertyInitializerOrClassStaticBlock(node ast.Node) bool`
`8073`	`8073`	`}`
`8074`	`8074`	`return ast.FindAncestorQuit`
`8075`	`8075`	`default:`
`8076`		`- if isExpressionNode(node) {`
	`8076`	`+ if IsExpressionNode(node) {`
`8077`	`8077`	`return ast.FindAncestorFalse`
`8078`	`8078`	`}`
`8079`	`8079`	`return ast.FindAncestorQuit`
`@@ -22736,6 +22736,14 @@ func (c Checker) getActualTypeVariable(t Type) *Type {`
`22736`	`22736`	`return t`
`22737`	`22737`	`}`
`22738`	`22738`
	`22739`	`+func (c Checker) GetSymbolAtLocation(node ast.Node) *ast.Symbol {`
	`22740`	`+ // !!!`
	`22741`	`+ // const node = getParseTreeNode(nodeIn);`
	`22742`	`+`
	`22743`	`+ // set ignoreErrors: true because any lookups invoked by the API shouldn't cause any new errors`
	`22744`	`+ return c.getSymbolAtLocation(node, true /ignoreErrors/)`
	`22745`	`+}`
	`22746`	`+`
`22739`	`22747`	`func (c Checker) getSymbolAtLocation(node ast.Node, ignoreErrors bool) *ast.Symbol {`
`22740`	`22748`	`if ast.IsSourceFile(node) {`
`22741`	`22749`	`if ast.IsExternalModule(node.AsSourceFile()) {`
`@@ -22963,7 +22971,7 @@ func (c Checker) getSymbolOfNameOrPropertyAccessExpression(name ast.Node) *ast`
`22963`	`22971`	`}`
`22964`	`22972`	`}`
`22965`	`22973`
`22966`		`- if isExpressionNode(name) {`
	`22974`	`+ if IsExpressionNode(name) {`
`22967`	`22975`	`if ast.NodeIsMissing(name) {`
`22968`	`22976`	`// Missing entity name.`
`22969`	`22977`	`return nil`
`@@ -23066,7 +23074,7 @@ func (c Checker) getTypeOfNode(node ast.Node) *Type {`
`23066`	`23074`	`return typeFromTypeNode`
`23067`	`23075`	`}`
`23068`	`23076`
`23069`		`- if isExpressionNode(node) {`
	`23077`	`+ if IsExpressionNode(node) {`
`23070`	`23078`	`return c.getRegularTypeOfExpression(node)`
`23071`	`23079`	`}`
`23072`	`23080`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ func (c Checker) checkGrammarPrivateIdentifierExpression(privId ast.PrivateIde`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`if !ast.IsForInStatement(privId.Parent) {`
`100`		`- if !isExpressionNode(privIdAsNode) {`
	`100`	`+ if !IsExpressionNode(privIdAsNode) {`
`101`	`101`	`return c.grammarErrorOnNode(privIdAsNode, diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression)`
`102`	`102`	`}`
`103`	`103`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,10 @@ func (c Checker) getTypePrecedence(t Type) ast.TypePrecedence {`
`27`	`27`	`return ast.TypePrecedenceNonArray`
`28`	`28`	`}`
`29`	`29`
	`30`	`+func (c Checker) SymbolToString(s ast.Symbol) string {`
	`31`	`+ return c.symbolToString(s)`
	`32`	`+}`
	`33`	`+`
`30`	`34`	`func (c Checker) symbolToString(s ast.Symbol) string {`
`31`	`35`	`if s.ValueDeclaration != nil {`
`32`	`36`	`name := ast.GetNameOfDeclaration(s.ValueDeclaration)`
`@@ -571,7 +575,7 @@ func (c Checker) getTextAndTypeOfNode(node ast.Node) (string, *Type, bool) {`
`571`	`575`	`}`
`572`	`576`	`}`
`573`	`577`	`}`
`574`		`- if isExpressionNode(node) && !isRightSideOfQualifiedNameOrPropertyAccess(node) {`
	`578`	`+ if IsExpressionNode(node) && !isRightSideOfQualifiedNameOrPropertyAccess(node) {`
`575`	`579`	`return scanner.GetTextOfNode(node), c.getTypeOfExpression(node), false`
`576`	`580`	`}`
`577`	`581`	`return "", nil, false`
Original file line number	Diff line number	Diff line change
`@@ -360,7 +360,7 @@ func (p Program) GetSemanticDiagnostics(sourceFile ast.SourceFile) []*ast.Diag`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`func (p Program) GetGlobalDiagnostics() []ast.Diagnostic {`
`363`		`- return sortAndDeduplicateDiagnostics(p.getTypeChecker().GetGlobalDiagnostics())`
	`363`	`+ return sortAndDeduplicateDiagnostics(p.GetTypeChecker().GetGlobalDiagnostics())`
`364`	`364`	`}`
`365`	`365`
`366`	`366`	`func (p *Program) TypeCount() int {`
`@@ -370,7 +370,7 @@ func (p *Program) TypeCount() int {`
`370`	`370`	`return int(p.checker.typeCount)`
`371`	`371`	`}`
`372`	`372`
`373`		`-func (p Program) getTypeChecker() Checker {`
	`373`	`+func (p Program) GetTypeChecker() Checker {`
`374`	`374`	`if p.checker == nil {`
`375`	`375`	`p.checker = NewChecker(p)`
`376`	`376`	`}`
`@@ -386,7 +386,7 @@ func (p Program) getBindDiagnosticsForFile(sourceFile ast.SourceFile) []*ast.D`
`386`	`386`	`}`
`387`	`387`
`388`	`388`	`func (p Program) getSemanticDiagnosticsForFile(sourceFile ast.SourceFile) []*ast.Diagnostic {`
`389`		`- return core.Concatenate(sourceFile.BindDiagnostics(), p.getTypeChecker().GetDiagnostics(sourceFile))`
	`389`	`+ return core.Concatenate(sourceFile.BindDiagnostics(), p.GetTypeChecker().GetDiagnostics(sourceFile))`
`390`	`390`	`}`
`391`	`391`
`392`	`392`	`func (p Program) getDiagnosticsHelper(sourceFile ast.SourceFile, ensureBound bool, getDiagnostics func(ast.SourceFile) []ast.Diagnostic) []*ast.Diagnostic {`
`@@ -414,7 +414,7 @@ type NodeCount struct {`
`414`	`414`	`func (p *Program) PrintSourceFileWithTypes() {`
`415`	`415`	`for _, file := range p.files {`
`416`	`416`	`if tspath.GetBaseFileName(file.FileName()) == "main.ts" {`
`417`		`- fmt.Print(p.getTypeChecker().sourceFileWithTypes(file))`
	`417`	`+ fmt.Print(p.GetTypeChecker().sourceFileWithTypes(file))`
`418`	`418`	`}`
`419`	`419`	`}`
`420`	`420`	`}`
`@@ -785,3 +785,8 @@ func (p Program) Emit(options EmitOptions) *EmitResult {`
`785`	`785`	`}`
`786`	`786`	`return result`
`787`	`787`	`}`
	`788`	`+`
	`789`	`+func (p Program) GetSourceFile(filename string) ast.SourceFile {`
	`790`	`+ path := tspath.ToPath(filename, p.host.GetCurrentDirectory(), p.host.FS().UseCaseSensitiveFileNames())`
	`791`	`+ return p.filesByPath[path]`
	`792`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -993,7 +993,7 @@ func isValidTypeOnlyAliasUseSite(useSite *ast.Node) bool {`
`993`	`993`	`ast.IsPartOfTypeQuery(useSite) \|\|`
`994`	`994`	`isIdentifierInNonEmittingHeritageClause(useSite) \|\|`
`995`	`995`	`isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) \|\|`
`996`		`- !(isExpressionNode(useSite) \|\| isShorthandPropertyNameUseSite(useSite))`
	`996`	`+ !(IsExpressionNode(useSite) \|\| isShorthandPropertyNameUseSite(useSite))`
`997`	`997`	`}`
`998`	`998`
`999`	`999`	`func isIdentifierInNonEmittingHeritageClause(node *ast.Node) bool {`
`@@ -1062,7 +1062,7 @@ func nodeCanBeDecorated(useLegacyDecorators bool, node ast.Node, parent ast.No`
`1062`	`1062`	`return false`
`1063`	`1063`	`}`
`1064`	`1064`
`1065`		`-func isExpressionNode(node *ast.Node) bool {`
	`1065`	`+func IsExpressionNode(node *ast.Node) bool {`
`1066`	`1066`	`switch node.Kind {`
`1067`	`1067`	`case ast.KindSuperKeyword, ast.KindNullKeyword, ast.KindTrueKeyword, ast.KindFalseKeyword, ast.KindRegularExpressionLiteral,`
`1068`	`1068`	`ast.KindArrayLiteralExpression, ast.KindObjectLiteralExpression, ast.KindPropertyAccessExpression, ast.KindElementAccessExpression,`
`@@ -1154,7 +1154,7 @@ func isInExpressionContext(node *ast.Node) bool {`
`1154`	`1154`	`case ast.KindSatisfiesExpression:`
`1155`	`1155`	`return parent.AsSatisfiesExpression().Expression == node`
`1156`	`1156`	`default:`
`1157`		`- return isExpressionNode(parent)`
	`1157`	`+ return IsExpressionNode(parent)`
`1158`	`1158`	`}`
`1159`	`1159`	`}`
`1160`	`1160`
Original file line number	Diff line number	Diff line change
`@@ -15,11 +15,11 @@ type Options struct {`
`15`	`15`
`16`	`16`	`const NoContent = "<no content>"`
`17`	`17`
`18`		`-func Run(t testing.TB, fileName string, actual string, opts Options) {`
	`18`	`+func Run(t *testing.T, fileName string, actual string, opts Options) {`
`19`	`19`	`writeComparison(t, actual, fileName, opts)`
`20`	`20`	`}`
`21`	`21`
`22`		`-func writeComparison(t testing.TB, actual string, relativeFileName string, opts Options) {`
	`22`	`+func writeComparison(t *testing.T, actual string, relativeFileName string, opts Options) {`
`23`	`23`	`if actual == "" {`
`24`	`24`	`panic("The generated content was \"\". Return 'baseline.NoContent' if no baselining is required.")`
`25`	`25`	`}`