.

Author: lihaoyi

core/api/src/mill/api/Module.scala

@@ -45,7 +45,7 @@ trait Module extends Module.BaseClass with ModuleCtx.Wrapper with ModuleApi {
   private[mill] val moduleLinearized: Seq[Class[?]] =
     OverrideMapping.computeLinearization(this.getClass)
 
-  private[mill] def moduleDynamicBuildOverrides: Map[String, internal.Located[BufferedValue]] =
+  private[mill] def moduleDynamicBuildOverrides: Map[String, internal.AppendLocated[BufferedValue]] =
     Map()
 }
 

core/api/src/mill/api/ModuleCtx.scala

@@ -46,7 +46,7 @@ object ModuleCtx extends LowPriCtx {
     def moduleSegments: Segments = moduleCtx.segments
     def moduleCtx: ModuleCtx
     private[mill] def moduleLinearized: Seq[Class[?]]
-    private[mill] def moduleDynamicBuildOverrides: Map[String, internal.Located[BufferedValue]] =
+    private[mill] def moduleDynamicBuildOverrides: Map[String, internal.AppendLocated[BufferedValue]] =
       Map()
   }
 

core/api/src/mill/api/ScriptModule.scala

@@ -24,8 +24,21 @@ trait ScriptModule extends ExternalModule {
     .headerData
     .rest
     .map { case (k, v) =>
+      import upickle.core.BufferedValue
       val newKey = (moduleSegments ++ mill.api.Segment.Label(k.value)).render
-      (newKey, internal.Located(scriptConfig.scriptFile, k.index, v))
+      // Extract append flag from marker object if present
+      val (actualValue, append) = v match {
+        case obj: BufferedValue.Obj =>
+          val kvMap = obj.value0.collect { case (BufferedValue.Str(k, _), v) =>
+            k.toString -> v
+          }.toMap
+          (kvMap.get("__mill_append__"), kvMap.get("__mill_values__")) match {
+            case (Some(BufferedValue.True(_)), Some(values)) => (values, true)
+            case _ => (v, false)
+          }
+        case _ => (v, false)
+      }
+      (newKey, internal.AppendLocated(internal.Located(scriptConfig.scriptFile, k.index, actualValue), append))
     }
 }
 @experimental

core/api/src/mill/api/internal/Located.scala

@@ -9,6 +9,29 @@ case class AppendLocated[T](located: Located[T], append: Boolean) {
   def value: T = located.value
 }
 
+object AppendLocated {
+  import upickle.core.BufferedValue
+
+  /**
+   * Extract append flag and actual value from a BufferedValue that may contain
+   * the `__mill_append__` marker object (produced by YAML `!append` tag parsing).
+   * Returns (actualValue, appendFlag).
+   */
+  def unwrapAppendMarker(v: BufferedValue): (BufferedValue, Boolean) = {
+    v match {
+      case obj: BufferedValue.Obj =>
+        val kvMap = obj.value0.collect { case (BufferedValue.Str(k, _), v) =>
+          k.toString -> v
+        }.toMap
+        (kvMap.get("__mill_append__"), kvMap.get("__mill_values__")) match {
+          case (Some(BufferedValue.True(_)), Some(values)) => (values, true)
+          case _ => (v, false)
+        }
+      case _ => (v, false)
+    }
+  }
+}
+
 object Located {
   class UpickleReader[T](path: os.Path)(implicit r: upickle.Reader[T])
       extends upickle.Reader[Located[T]] {

core/exec/src/mill/exec/GroupExecution.scala

@@ -62,20 +62,6 @@ trait GroupExecution {
     }
   }
 
-  /** Extract append flag and actual value from wrapper object if present */
-  private def unwrapAppendMarker(v: BufferedValue): (BufferedValue, Boolean) = {
-    v match {
-      case obj: BufferedValue.Obj =>
-        val kvMap = obj.value0.collect { case (BufferedValue.Str(k, _), v) =>
-          k.toString -> v
-        }.toMap
-        (kvMap.get("__mill_append__"), kvMap.get("__mill_values__")) match {
-          case (Some(BufferedValue.True(_)), Some(values)) => (values, true)
-          case _ => (v, false)
-        }
-      case _ => (v, false)
-    }
-  }
 
   val staticBuildOverrides: Map[String, AppendLocated[BufferedValue]] = staticBuildOverrideFiles
     .flatMap { case (path0, rawText) =>
@@ -105,7 +91,7 @@ trait GroupExecution {
           )
             .rest
             .map { case (k, v) =>
-              val (actualValue, append) = unwrapAppendMarker(v)
+              val (actualValue, append) = AppendLocated.unwrapAppendMarker(v)
               (segments ++ Seq(k.value)).mkString(".") -> AppendLocated(
                 Located(path, k.index, actualValue),
                 append
@@ -228,9 +214,7 @@ trait GroupExecution {
         val paths = ExecutionPaths.resolve(out, labelled.ctx.segments)
         val dynamicBuildOverride = labelled.ctx.enclosingModule.moduleDynamicBuildOverrides
         val buildOverrideOpt = staticBuildOverrides.get(labelled.ctx.segments.render)
-          .orElse(dynamicBuildOverride.get(labelled.ctx.segments.render).map(loc =>
-            AppendLocated(loc, append = false)
-          ))
+          .orElse(dynamicBuildOverride.get(labelled.ctx.segments.render))
 
         // Helper to evaluate the task with full caching support
         def evaluateTaskWithCaching(): GroupExecution.Results = {