Separate definition types and reference types

We need to distinguish TaskID/Task/TaskRef, OutputDef/OutputRef for
parametrized tasks.

1 files changed, 8 insertions, 8 deletions

diff --git a/src/executor.rs b/src/executor.rs
index 145176c..a953271 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
 	paths, resolve, runner,
+	task::{self, *},
 	types::*,
 	util::{cjson, error::*, fs},
 };
@@ -99,7 +100,7 @@ impl<'a> Executor<'a> {
 			let task_def = tasks.get(&task.id).expect("Invalid TaskRef");
 
 			let mut has_depends = false;
-			for dep in task_def.get_depend_tasks() {
+			for dep in get_dependent_tasks(task_def) {
 				let rdep = exc.rdeps.entry(dep.clone()).or_default();
 				rdep.push(task.clone());
 				has_depends = true;
@@ -121,11 +122,10 @@ impl<'a> Executor<'a> {
 	fn deps_satisfied(&self, task_ref: &TaskRef) -> bool {
 		let task = self.tasks.get(&task_ref.id).expect("Invalid TaskRef");
 
-		task.get_depend_tasks()
-			.all(|dep| self.tasks_done.contains_key(dep))
+		get_dependent_tasks(task).all(|dep| self.tasks_done.contains_key(&dep))
 	}
 
-	fn task_deps(&self, task: &Task) -> HashMap<DependencyHash, Dependency> {
+	fn task_deps(&self, task: &TaskDef) -> HashMap<DependencyHash, Dependency> {
 		task.fetch
 			.iter()
 			.map(|Fetch { name, sha256 }| Dependency::Fetch {
@@ -133,14 +133,14 @@ impl<'a> Executor<'a> {
 				sha256: *sha256,
 			})
 			.chain(
-				resolve::runtime_depends(self.tasks, &task.build_depends)
+				resolve::runtime_depends(self.tasks, task.build_depends.iter().map(output_ref))
 					.expect("invalid runtime depends of build_depends")
 					.iter()
 					.filter_map(|dep| self.tasks_done[&dep.task].output.get(&dep.output))
 					.map(|&output| Dependency::BuildTask { output }),
 			)
 			.chain(
-				resolve::runtime_depends(self.tasks, &task.target_depends)
+				resolve::runtime_depends(self.tasks, task.target_depends.iter().map(output_ref))
 					.expect("invalid runtime depends of target_depends")
 					.iter()
 					.filter_map(|dep| self.tasks_done[&dep.task].output.get(&dep.output))
@@ -165,8 +165,8 @@ impl<'a> Executor<'a> {
 			.collect();
 		let env = self.env.clone();
 
-		let (inherit_chain, inherit_hash) = if let Some(inherit_task) = &task_def.inherit {
-			let inherit_meta = &self.tasks_done[inherit_task];
+		let (inherit_chain, inherit_hash) = if let Some(inherit_dep) = &task_def.inherit {
+			let inherit_meta = &self.tasks_done[&task::task_ref(&inherit_dep.task)];
 			let mut inherit_chain = inherit_meta.inherit.clone();
 			inherit_chain.push(inherit_meta.input_hash);
 			(inherit_chain, Some(&inherit_meta.input_hash))