Revert introduction of Dependency enum

We will represent all kinds of dependencies as tasks instead.

4 files changed, 18 insertions, 23 deletions

diff --git a/src/executor.rs b/src/executor.rs
index 7c5bbee..fc12725 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -33,7 +33,7 @@ pub struct Executor<'a> {
 	tasks: &'a TaskMap,
 	tasks_blocked: HashSet<TaskRef>,
 	tasks_runnable: Vec<TaskRef>,
-	tasks_done: HashMap<Dependency, TaskOutput>,
+	tasks_done: HashMap<TaskRef, TaskOutput>,
 	rdeps: HashMap<TaskRef, Vec<TaskRef>>,
 	env: HashMap<String, String>,
 }
@@ -60,8 +60,7 @@ impl<'a> Executor<'a> {
 				exc.tasks_runnable.push(task);
 			} else {
 				for dep in &task_def.depends {
-					let Dependency::Task(dep_task) = dep;
-					let rdep = exc.rdeps.entry(dep_task.clone()).or_default();
+					let rdep = exc.rdeps.entry(dep.clone()).or_default();
 					rdep.push(task.clone());
 				}
 
@@ -86,7 +85,7 @@ impl<'a> Executor<'a> {
 			.all(|dep| self.tasks_done.contains_key(dep))
 	}
 
-	fn task_deps(&self, task: &TaskDef) -> HashMap<OutputHash, Dependency> {
+	fn task_deps(&self, task: &TaskDef) -> HashMap<OutputHash, TaskRef> {
 		task.depends
 			.iter()
 			.map(|dep| {
@@ -102,12 +101,12 @@ impl<'a> Executor<'a> {
 	}
 
 	fn run_one(&mut self, runner: &impl runner::Runner) -> runner::Result<()> {
-		let task_id = self.tasks_runnable.pop().expect("No runnable tasks left");
-		let task_def = self.tasks.get(&task_id).expect("Invalid TaskRef");
+		let task_ref = self.tasks_runnable.pop().expect("No runnable tasks left");
+		let task_def = self.tasks.get(&task_ref).expect("Invalid TaskRef");
 		let task_deps = self.task_deps(&task_def);
 
 		let task = Task {
-			id: task_id,
+			id: task_ref.clone(),
 			def: task_def.clone(),
 			depends: task_deps,
 			env: self.env.clone(),
@@ -127,7 +126,7 @@ impl<'a> Executor<'a> {
 		save_output(&output)?;
 
 		let rdeps = self.rdeps.get(&task.id);
-		self.tasks_done.insert(Dependency::Task(task.id), output);
+		self.tasks_done.insert(task_ref, output);
 
 		for rdep in rdeps.unwrap_or(&Vec::new()) {
 			if !self.tasks_blocked.contains(rdep) {
diff --git a/src/main.rs b/src/main.rs
index 25bc6c4..5f68fae 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -37,7 +37,7 @@ fn main() {
 	let mut rsv = resolve::Resolver::new(&tasks);
 
 	for task in opts.tasks {
-		let errors = rsv.add_goal(&TaskRef(task));
+		let errors = rsv.add_goal(&TaskRef { id: task });
 		if !errors.is_empty() {
 			for error in errors {
 				eprintln!("{}", error);
diff --git a/src/resolve.rs b/src/resolve.rs
index 87fd9e0..f3ad284 100644
--- a/src/resolve.rs
+++ b/src/resolve.rs
@@ -99,8 +99,7 @@ impl<'a> Resolver<'a> {
 		let mut ret = Vec::new();
 
 		for dep in &task_def.depends {
-			let Dependency::Task(dep_task) = dep;
-			let errors = self.add_task(dep_task);
+			let errors = self.add_task(dep);
 			for mut error in errors {
 				error.extend(task.clone());
 				ret.push(error);
diff --git a/src/types.rs b/src/types.rs
index 2c94679..9479925 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -43,24 +43,21 @@ pub type OutputHasher = Sha256;
 pub type OutputHash = StringHash;
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, Hash)]
-pub struct TaskRef(pub String);
+pub struct TaskRef {
+	#[serde(rename = "task")]
+	pub id: String,
+}
 
 impl Display for TaskRef {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		self.0.fmt(f)
+		self.id.fmt(f)
 	}
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, Hash)]
-pub enum Dependency {
-	#[serde(rename = "task")]
-	Task(TaskRef),
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct TaskDef {
 	#[serde(default)]
-	pub depends: Vec<Dependency>,
+	pub depends: Vec<TaskRef>,
 	#[serde(default)]
 	pub run: String,
 }
@@ -69,7 +66,7 @@ pub struct TaskDef {
 pub struct Task {
 	pub id: TaskRef,
 	pub def: TaskDef,
-	pub depends: HashMap<OutputHash, Dependency>,
+	pub depends: HashMap<OutputHash, TaskRef>,
 	pub env: HashMap<String, String>,
 }
 
@@ -84,14 +81,14 @@ pub struct TaskMap(pub HashMap<String, TaskDef>);
 
 impl TaskMap {
 	pub fn get(&self, task: &TaskRef) -> Option<&TaskDef> {
-		self.0.get(&task.0)
+		self.0.get(&task.id)
 	}
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct TaskOutput {
 	pub id: TaskRef,
-	pub depends: HashMap<OutputHash, Dependency>,
+	pub depends: HashMap<OutputHash, TaskRef>,
 	pub env: HashMap<String, String>,
 	pub input_hash: InputHash,
 	pub output_hash: OutputHash,