DRAFT

Author: cmaglie

internal/arduino/builder/internal/detector/cache.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/arduino/arduino-cli/internal/arduino/builder/internal/runner"
 	"github.com/arduino/go-paths-helper"
+	"github.com/sirupsen/logrus"
 )
 
 type detectorCache struct {
@@ -83,6 +84,15 @@ func (c *detectorCache) Load(cacheFile *paths.Path) error {
 	if err := json.Unmarshal(data, &entries); err != nil {
 		return err
 	}
+	// Check for invalid entries (stale files from previous Arduino CLI versions)
+	for _, entry := range entries {
+		if entry == nil {
+			return nil
+		}
+		if entry.Compile != nil && entry.CompileTask == nil {
+			return nil
+		}
+	}
 	c.curr = 0
 	c.entries = entries
 	return nil
@@ -91,11 +101,14 @@ func (c *detectorCache) Load(cacheFile *paths.Path) error {
 // Expect adds an entry to the cache and checks if it matches the next expected entry.
 func (c *detectorCache) Expect(entry *detectorCacheEntry) {
 	if c.curr < len(c.entries) {
+		logrus.Debugf("Expecting cache entry: %s", entry)
 		if c.entries[c.curr].Equals(entry) {
 			// Cache hit, move to the next entry
 			c.curr++
+			logrus.Debugf("  CACHE HIT!")
 			return
 		}
+		logrus.Debugf("  Cache MISMATCH!")
 		// Cache mismatch, invalidate and cut the remainder of the cache
 		c.entries = c.entries[:c.curr]
 	}

internal/arduino/builder/internal/detector/detector.go

@@ -41,6 +41,7 @@ import (
 	"github.com/arduino/arduino-cli/internal/i18n"
 	"github.com/arduino/go-paths-helper"
 	"github.com/arduino/go-properties-orderedmap"
+	"github.com/sirupsen/logrus"
 )
 
 type libraryResolutionResult struct {
@@ -273,8 +274,9 @@ func (l *SketchLibrariesDetector) findIncludes(
 	l.preRunner = runner.New(ctx, jobs)
 	for _, entry := range l.cache.EntriesAhead() {
 		if entry.Compile != nil && entry.CompileTask != nil {
-			upToDate, _ := entry.Compile.ObjFileIsUpToDate()
+			upToDate, _ := entry.Compile.ObjFileIsUpToDate(logrus.WithField("source_file", entry.Compile.SourcePath))
 			if !upToDate {
+				_ = entry.Compile.PrepareBuildPath()
 				l.preRunner.Enqueue(entry.CompileTask)
 			}
 		}
@@ -360,7 +362,8 @@ func (l *SketchLibrariesDetector) gccPreprocessTask(sourceFile *sourceFile, buil
 		includeFolders = append(includeFolders, extraInclude)
 	}
 
-	return preprocessor.GCC(sourceFile.SourcePath, paths.NullPath(), includeFolders, buildProperties, nil)
+	_ = sourceFile.PrepareBuildPath()
+	return preprocessor.GCC(sourceFile.SourcePath, paths.NullPath(), includeFolders, buildProperties, sourceFile.DepfilePath)
 }
 
 func (l *SketchLibrariesDetector) findMissingIncludesInCompilationUnit(
@@ -385,7 +388,7 @@ func (l *SketchLibrariesDetector) findMissingIncludesInCompilationUnit(
 	// TODO: This reads the dependency file, but the actual building
 	// does it again. Should the result be somehow cached? Perhaps
 	// remove the object file if it is found to be stale?
-	unchanged, err := sourceFile.ObjFileIsUpToDate()
+	unchanged, err := sourceFile.ObjFileIsUpToDate(logrus.WithField("source_file", sourcePath))
 	if err != nil {
 		return err
 	}
@@ -533,8 +536,7 @@ func (l *SketchLibrariesDetector) makeSourceFile(sourceRoot, buildRoot, sourceFi
 	}
 	res := &sourceFile{
 		SourcePath:       sourceRoot.JoinPath(sourceFilePath),
-		ObjectPath:       buildRoot.Join(sourceFilePath.String() + ".o"),
-		DepfilePath:      buildRoot.Join(sourceFilePath.String() + ".d"),
+		DepfilePath:      buildRoot.Join(fmt.Sprintf("%s.libsdetect.d", sourceFilePath)),
 		ExtraIncludePath: extraIncludePath,
 	}
 	return res, nil

internal/arduino/builder/internal/detector/source_file.go

@@ -19,17 +19,17 @@ import (
 	"fmt"
 	"slices"
 
-	"github.com/arduino/arduino-cli/internal/arduino/builder/internal/utils"
+	"os"
+
+	"github.com/arduino/arduino-cli/internal/arduino/builder/cpp"
 	"github.com/arduino/go-paths-helper"
+	"github.com/sirupsen/logrus"
 )
 
 type sourceFile struct {
 	// SourcePath is the path to the source file
 	SourcePath *paths.Path `json:"source_path"`
 
-	// ObjectPath is the path to the object file that will be generated
-	ObjectPath *paths.Path `json:"object_path"`
-
 	// DepfilePath is the path to the dependency file that will be generated
 	DepfilePath *paths.Path `json:"depfile_path"`
 
@@ -41,22 +41,82 @@ type sourceFile struct {
 }
 
 func (f *sourceFile) String() string {
-	return fmt.Sprintf("SourcePath:%s SourceRoot:%s BuildRoot:%s ExtraInclude:%s",
-		f.SourcePath, f.ObjectPath, f.DepfilePath, f.ExtraIncludePath)
+	return fmt.Sprintf("%s -> dep:%s (ExtraInclude:%s)",
+		f.SourcePath, f.DepfilePath, f.ExtraIncludePath)
 }
 
 // Equals checks if a sourceFile is equal to another.
 func (f *sourceFile) Equals(g *sourceFile) bool {
 	return f.SourcePath.EqualsTo(g.SourcePath) &&
-		f.ObjectPath.EqualsTo(g.ObjectPath) &&
 		f.DepfilePath.EqualsTo(g.DepfilePath) &&
 		((f.ExtraIncludePath == nil && g.ExtraIncludePath == nil) ||
 			(f.ExtraIncludePath != nil && g.ExtraIncludePath != nil && f.ExtraIncludePath.EqualsTo(g.ExtraIncludePath)))
 }
 
+// PrepareBuildPath ensures that the directory for the dependency file exists.
+func (f *sourceFile) PrepareBuildPath() error {
+	if f.DepfilePath != nil {
+		return f.DepfilePath.Parent().MkdirAll()
+	}
+	return nil
+}
+
 // ObjFileIsUpToDate checks if the compile object file is up to date.
-func (f *sourceFile) ObjFileIsUpToDate() (unchanged bool, err error) {
-	return utils.ObjFileIsUpToDate(f.SourcePath, f.ObjectPath, f.DepfilePath)
+func (f *sourceFile) ObjFileIsUpToDate(log *logrus.Entry) (unchanged bool, err error) {
+	log.Debugf("Checking previous results for %v (dep = %v)", f.SourcePath, f.DepfilePath)
+	if f.DepfilePath == nil {
+		log.Debugf("  Object file or dependency file not provided")
+		return false, nil
+	}
+
+	sourceFile := f.SourcePath.Clean()
+	sourceFileStat, err := sourceFile.Stat()
+	if err != nil {
+		log.Debugf("  Could not stat source file: %s", err)
+		return false, err
+	}
+	dependencyFile := f.DepfilePath.Clean()
+	dependencyFileStat, err := dependencyFile.Stat()
+	if err != nil {
+		if os.IsNotExist(err) {
+			log.Debugf("  Dependency file not found: %v", dependencyFile)
+			return false, nil
+		}
+		log.Debugf("  Could not stat dependency file: %s", err)
+		return false, err
+	}
+	if sourceFileStat.ModTime().After(dependencyFileStat.ModTime()) {
+		log.Debugf("  %v newer than %v", sourceFile, dependencyFile)
+		return false, nil
+	}
+	deps, err := cpp.ReadDepFile(dependencyFile)
+	if err != nil {
+		log.Debugf("  Could not read dependency file: %s", dependencyFile)
+		return false, err
+	}
+	if len(deps.Dependencies) == 0 {
+		return true, nil
+	}
+	if deps.Dependencies[0] != sourceFile.String() {
+		log.Debugf("  Depfile is about different source file: %v (expected %v)", deps.Dependencies[0], sourceFile)
+		return false, nil
+	}
+	for _, dep := range deps.Dependencies[1:] {
+		depStat, err := os.Stat(dep)
+		if os.IsNotExist(err) {
+			log.Debugf("  Not found: %v", dep)
+			return false, nil
+		}
+		if err != nil {
+			logrus.WithError(err).Debugf("  Failed to read: %v", dep)
+			return false, nil
+		}
+		if depStat.ModTime().After(dependencyFileStat.ModTime()) {
+			log.Debugf("  %v newer than %v", dep, dependencyFile)
+			return false, nil
+		}
+	}
+	return true, nil
 }
 
 // uniqueSourceFileQueue is a queue of source files that does not allow duplicates.