Write signature and its text for testing

Author: sheetalkamat

internal/incremental/affectedfileshandler.go

@@ -2,11 +2,8 @@ package incremental
 
 import (
 	"context"
-	"crypto/sha256"
-	"fmt"
 	"maps"
 	"slices"
-	"strings"
 	"sync"
 	"sync/atomic"
 
@@ -71,7 +68,7 @@ func (h *affectedFilesHandler) computeDtsSignature(file *ast.SourceFile) string
 			if !tspath.IsDeclarationFileName(fileName) {
 				panic("File extension for signature expected to be dts, got : " + fileName)
 			}
-			signature = computeSignatureWithDiagnostics(file, text, data)
+			signature = h.program.snapshot.computeSignatureWithDiagnostics(file, text, data)
 			return nil
 		},
 	})
@@ -394,50 +391,3 @@ func collectAllAffectedFiles(ctx context.Context, program *Program) {
 	// Update the snapshot with the new state
 	handler.updateSnapshot()
 }
-
-func getTextHandlingSourceMapForSignature(text string, data *compiler.WriteFileData) string {
-	if data.SourceMapUrlPos != -1 {
-		return text[:data.SourceMapUrlPos]
-	}
-	return text
-}
-
-func computeSignatureWithDiagnostics(file *ast.SourceFile, text string, data *compiler.WriteFileData) string {
-	var builder strings.Builder
-	builder.WriteString(getTextHandlingSourceMapForSignature(text, data))
-	for _, diag := range data.Diagnostics {
-		diagnosticToStringBuilder(diag, file, &builder)
-	}
-	return computeHash(builder.String())
-}
-
-func diagnosticToStringBuilder(diagnostic *ast.Diagnostic, file *ast.SourceFile, builder *strings.Builder) string {
-	if diagnostic == nil {
-		return ""
-	}
-	builder.WriteString("\n")
-	if diagnostic.File() != file {
-		builder.WriteString(tspath.EnsurePathIsNonModuleName(tspath.GetRelativePathFromDirectory(
-			tspath.GetDirectoryPath(string(file.Path())),
-			string(diagnostic.File().Path()),
-			tspath.ComparePathsOptions{},
-		)))
-	}
-	if diagnostic.File() != nil {
-		builder.WriteString(fmt.Sprintf("(%d,%d): ", diagnostic.Pos(), diagnostic.Len()))
-	}
-	builder.WriteString(diagnostic.Category().Name())
-	builder.WriteString(fmt.Sprintf("%d: ", diagnostic.Code()))
-	builder.WriteString(diagnostic.Message())
-	for _, chain := range diagnostic.MessageChain() {
-		diagnosticToStringBuilder(chain, file, builder)
-	}
-	for _, info := range diagnostic.RelatedInformation() {
-		diagnosticToStringBuilder(info, file, builder)
-	}
-	return builder.String()
-}
-
-func computeHash(text string) string {
-	return fmt.Sprintf("%x", sha256.Sum256([]byte(text)))
-}

internal/incremental/emitfileshandler.go

@@ -151,7 +151,7 @@ func (h *emitFilesHandler) getEmitOptions(options compiler.EmitOptions) compiler
 				var emitSignature string
 				info := h.program.snapshot.fileInfos[options.TargetSourceFile.Path()]
 				if info.signature == info.version {
-					signature := computeSignatureWithDiagnostics(options.TargetSourceFile, text, data)
+					signature := h.program.snapshot.computeSignatureWithDiagnostics(options.TargetSourceFile, text, data)
 					// With d.ts diagnostics they are also part of the signature so emitSignature will be different from it since its just hash of d.ts
 					if len(data.Diagnostics) == 0 {
 						emitSignature = signature
@@ -193,7 +193,7 @@ func (h *emitFilesHandler) skipDtsOutputOfComposite(file *ast.SourceFile, output
 		}
 	}
 	if newSignature == "" {
-		newSignature = computeHash(getTextHandlingSourceMapForSignature(text, data))
+		newSignature = h.program.snapshot.computeHash(getTextHandlingSourceMapForSignature(text, data))
 	}
 	// Dont write dts files if they didn't change
 	if newSignature == oldSignature {

internal/incremental/program.go

@@ -34,7 +34,7 @@ var _ compiler.AnyProgram = (*Program)(nil)
 
 func NewProgram(program *compiler.Program, oldProgram *Program, testing bool) *Program {
 	incrementalProgram := &Program{
-		snapshot: newSnapshotForProgram(program, oldProgram),
+		snapshot: newSnapshotForProgram(program, oldProgram, testing),
 		program:  program,
 	}
 

internal/incremental/snapshot.go

@@ -2,7 +2,10 @@ package incremental
 
 import (
 	"context"
+	"crypto/sha256"
+	"fmt"
 	"maps"
+	"strings"
 	"sync"
 
 	"github.com/microsoft/typescript-go/internal/ast"
@@ -213,6 +216,9 @@ type snapshot struct {
 	allFilesExcludingDefaultLibraryFileOnce sync.Once
 	//  Cache of all files excluding default library file for the current program
 	allFilesExcludingDefaultLibraryFile []*ast.SourceFile
+
+	// Used with testing to add text of hash for better comparison
+	hashWithText bool
 }
 
 func (s *snapshot) createEmitSignaturesMap() {
@@ -257,14 +263,66 @@ func (s *snapshot) getAllFilesExcludingDefaultLibraryFile(program *compiler.Prog
 	return s.allFilesExcludingDefaultLibraryFile
 }
 
-func newSnapshotForProgram(program *compiler.Program, oldProgram *Program) *snapshot {
+func getTextHandlingSourceMapForSignature(text string, data *compiler.WriteFileData) string {
+	if data.SourceMapUrlPos != -1 {
+		return text[:data.SourceMapUrlPos]
+	}
+	return text
+}
+
+func (s *snapshot) computeSignatureWithDiagnostics(file *ast.SourceFile, text string, data *compiler.WriteFileData) string {
+	var builder strings.Builder
+	builder.WriteString(getTextHandlingSourceMapForSignature(text, data))
+	for _, diag := range data.Diagnostics {
+		diagnosticToStringBuilder(diag, file, &builder)
+	}
+	return s.computeHash(builder.String())
+}
+
+func diagnosticToStringBuilder(diagnostic *ast.Diagnostic, file *ast.SourceFile, builder *strings.Builder) string {
+	if diagnostic == nil {
+		return ""
+	}
+	builder.WriteString("\n")
+	if diagnostic.File() != file {
+		builder.WriteString(tspath.EnsurePathIsNonModuleName(tspath.GetRelativePathFromDirectory(
+			tspath.GetDirectoryPath(string(file.Path())),
+			string(diagnostic.File().Path()),
+			tspath.ComparePathsOptions{},
+		)))
+	}
+	if diagnostic.File() != nil {
+		builder.WriteString(fmt.Sprintf("(%d,%d): ", diagnostic.Pos(), diagnostic.Len()))
+	}
+	builder.WriteString(diagnostic.Category().Name())
+	builder.WriteString(fmt.Sprintf("%d: ", diagnostic.Code()))
+	builder.WriteString(diagnostic.Message())
+	for _, chain := range diagnostic.MessageChain() {
+		diagnosticToStringBuilder(chain, file, builder)
+	}
+	for _, info := range diagnostic.RelatedInformation() {
+		diagnosticToStringBuilder(info, file, builder)
+	}
+	return builder.String()
+}
+
+func (s *snapshot) computeHash(text string) string {
+	hash := fmt.Sprintf("%x", sha256.Sum256([]byte(text)))
+	if s.hashWithText {
+		hash += "-" + text
+	}
+	return hash
+}
+
+func newSnapshotForProgram(program *compiler.Program, oldProgram *Program, hashWithText bool) *snapshot {
 	if oldProgram != nil && oldProgram.program == program {
 		return oldProgram.snapshot
 	}
 	files := program.GetSourceFiles()
 	snapshot := &snapshot{
 		options:                    program.Options(),
 		semanticDiagnosticsPerFile: make(map[tspath.Path]*diagnosticsOrBuildInfoDiagnosticsWithFileName, len(files)),
+		hashWithText:               hashWithText,
 	}
 	if oldProgram != nil && snapshot.options.Composite.IsTrue() {
 		snapshot.latestChangedDtsFile = oldProgram.snapshot.latestChangedDtsFile
@@ -304,7 +362,7 @@ func newSnapshotForProgram(program *compiler.Program, oldProgram *Program) *snap
 		snapshot.options.SkipDefaultLibCheck.IsTrue() == oldProgram.snapshot.options.SkipDefaultLibCheck.IsTrue()
 	snapshot.fileInfos = make(map[tspath.Path]*fileInfo, len(files))
 	for _, file := range files {
-		version := computeHash(file.Text())
+		version := snapshot.computeHash(file.Text())
 		impliedNodeFormat := program.GetSourceFileMetaData(file.Path()).ImpliedNodeFormat
 		affectsGlobalScope := fileAffectsGlobalScope(file)
 		var signature string