[2.x] fix: Auto-skip caching for tasks with java.io.File output type

When a task's return type contains java.io.File, automatically skip
ActionCache.cache() wrapping. This prevents stale cached File paths

The fix is in callActionCache: when containsFileType detects java.io.File
in the return type, it still processes Def.declareOutput via letOutput
but returns the body value directly instead of caching it.

Generated-by: GitHub Copilot (Claude Opus 4.6)

Author: speedcoder430

core-macros/src/main/scala/sbt/internal/util/appmacro/Cont.scala

@@ -178,6 +178,16 @@ trait Cont:
         case Left(l)  => (l, TypeRepr.of[Effect[A]])
         case Right(r) => (r, faTpe)
 
+      def containsFileType[A1: Type]: Boolean =
+        val fileRepr = TypeRepr.of[java.io.File]
+        def containsFile(tpe: TypeRepr): Boolean =
+          if tpe =:= fileRepr then true
+          else
+            tpe.dealias match
+              case AppliedType(_, args) => args.exists(containsFile)
+              case _                    => false
+        containsFile(TypeRepr.of[A1])
+
       val inputBuf = ListBuffer[Input]()
       val outputBuf = ListBuffer[Output]()
 
@@ -342,38 +352,42 @@ trait Cont:
           cacheConfigExpr: Expr[BuildWideCacheConfiguration],
           tags: List[CacheLevelTag],
       )(body: Expr[A1], input: Expr[A2]): Expr[A1] =
-        val codeContentHash =
-          try Expr[Long](body.show.##)
-          catch
-            case e: Throwable =>
-              Expr[Long](Printer.TreeStructure.show(body.asTerm).##)
-        val extraHash = Expr[Long](0L)
-        val aJsonFormat = summonJsonFormat[A1]
-        val aClassTag = summonClassTag[A1]
-        val inputHashWriter =
-          if TypeRepr.of[A2] =:= TypeRepr.of[Unit] then
-            '{
-              import BasicJsonProtocol.*
-              summon[HashWriter[Unit]]
-            }.asExprOf[HashWriter[A2]]
-          else summonHashWriter[A2]
-        val tagsExpr = '{ List(${ Varargs(tags.map(Expr[CacheLevelTag](_))) }*) }
-        val block = letOutput(outputs, cacheConfigExpr)(body)
-        '{
-          given HashWriter[A2] = $inputHashWriter
-          given JsonFormat[A1] = $aJsonFormat
-          given ClassTag[A1] = $aClassTag
-          ActionCache
-            .cache(
-              $input,
-              codeContentHash = Digest.dummy($codeContentHash),
-              extraHash = Digest.dummy($extraHash),
-              tags = $tagsExpr,
-              config = $cacheConfigExpr,
-            )({ _ =>
-              $block
-            })
-        }
+        if containsFileType[A1] then
+          val block = letOutput(outputs, cacheConfigExpr)(body)
+          '{ $block.value }
+        else
+          val codeContentHash =
+            try Expr[Long](body.show.##)
+            catch
+              case e: Throwable =>
+                Expr[Long](Printer.TreeStructure.show(body.asTerm).##)
+          val extraHash = Expr[Long](0L)
+          val aJsonFormat = summonJsonFormat[A1]
+          val aClassTag = summonClassTag[A1]
+          val inputHashWriter =
+            if TypeRepr.of[A2] =:= TypeRepr.of[Unit] then
+              '{
+                import BasicJsonProtocol.*
+                summon[HashWriter[Unit]]
+              }.asExprOf[HashWriter[A2]]
+            else summonHashWriter[A2]
+          val tagsExpr = '{ List(${ Varargs(tags.map(Expr[CacheLevelTag](_))) }*) }
+          val block = letOutput(outputs, cacheConfigExpr)(body)
+          '{
+            given HashWriter[A2] = $inputHashWriter
+            given JsonFormat[A1] = $aJsonFormat
+            given ClassTag[A1] = $aClassTag
+            ActionCache
+              .cache(
+                $input,
+                codeContentHash = Digest.dummy($codeContentHash),
+                extraHash = Digest.dummy($extraHash),
+                tags = $tagsExpr,
+                config = $cacheConfigExpr,
+              )({ _ =>
+                $block
+              })
+          }
 
       // This will generate following code for Def.declareOutput(...):
       //   var $o1: VirtualFile = null

sbt-app/src/sbt-test/cache/skip-file-cache/build.sbt

@@ -0,0 +1,14 @@
+import java.io.File
+
+val myFileTask = taskKey[File]("task that returns File")
+val checkFileTask = taskKey[Unit]("verifies file task returns correct value")
+
+myFileTask := {
+  new File(scalaVersion.value)
+}
+
+checkFileTask := Def.uncached {
+  val f = myFileTask.value
+  val expected = new File(scalaVersion.value)
+  assert(f == expected, s"Expected $expected but got $f")
+}

sbt-app/src/sbt-test/cache/skip-file-cache/test

@@ -0,0 +1,5 @@
+# File-returning tasks should not be cached, so
+# changing scalaVersion should immediately be reflected.
+> checkFileTask
+> set scalaVersion := "2.13.18"
+> checkFileTask