Rename some AST parts to be less odd

codegen-luajit/src/analyzer/localize.rs

@@ -1,7 +1,7 @@
 use std::collections::BTreeSet;
 
 use wasm_ast::{
-	node::{AnyBinOp, AnyCmpOp, AnyLoad, AnyStore, AnyUnOp, Function},
+	node::{BinOp, CmpOp, Intermediate, LoadAt, StoreAt, UnOp},
 	visit::{Driver, Visitor},
 };
 
@@ -10,25 +10,25 @@ struct Visit {
 }
 
 impl Visitor for Visit {
-	fn visit_any_load(&mut self, v: &AnyLoad) {
-		let name = v.op.as_name();
+	fn visit_load_at(&mut self, v: &LoadAt) {
+		let name = v.what.as_name();
 
 		self.result.insert(("load", name));
 	}
 
-	fn visit_any_store(&mut self, v: &AnyStore) {
-		let name = v.op.as_name();
+	fn visit_store_at(&mut self, v: &StoreAt) {
+		let name = v.what.as_name();
 
 		self.result.insert(("store", name));
 	}
 
-	fn visit_any_unop(&mut self, v: &AnyUnOp) {
+	fn visit_un_op(&mut self, v: &UnOp) {
 		let name = v.op.as_name();
 
 		self.result.insert(name);
 	}
 
-	fn visit_any_binop(&mut self, v: &AnyBinOp) {
+	fn visit_bin_op(&mut self, v: &BinOp) {
 		if v.op.as_operator().is_some() {
 			return;
 		}
@@ -38,7 +38,7 @@ impl Visitor for Visit {
 		self.result.insert(name);
 	}
 
-	fn visit_any_cmpop(&mut self, v: &AnyCmpOp) {
+	fn visit_cmp_op(&mut self, v: &CmpOp) {
 		if v.op.as_operator().is_some() {
 			return;
 		}
@@ -49,12 +49,12 @@ impl Visitor for Visit {
 	}
 }
 
-pub fn visit(func: &Function) -> BTreeSet<(&'static str, &'static str)> {
+pub fn visit(ir: &Intermediate) -> BTreeSet<(&'static str, &'static str)> {
 	let mut visit = Visit {
 		result: BTreeSet::new(),
 	};
 
-	func.accept(&mut visit);
+	ir.accept(&mut visit);
 
 	visit.result
 }

codegen-luajit/src/analyzer/memory.rs

@@ -1,7 +1,7 @@
 use std::collections::BTreeSet;
 
 use wasm_ast::{
-	node::{AnyLoad, AnyStore, Function, MemoryGrow, MemorySize},
+	node::{Intermediate, LoadAt, MemoryGrow, MemorySize, StoreAt},
 	visit::{Driver, Visitor},
 };
 
@@ -10,11 +10,11 @@ struct Visit {
 }
 
 impl Visitor for Visit {
-	fn visit_any_store(&mut self, _: &AnyStore) {
+	fn visit_store_at(&mut self, _: &StoreAt) {
 		self.result.insert(0);
 	}
 
-	fn visit_any_load(&mut self, _: &AnyLoad) {
+	fn visit_load_at(&mut self, _: &LoadAt) {
 		self.result.insert(0);
 	}
 
@@ -27,12 +27,12 @@ impl Visitor for Visit {
 	}
 }
 
-pub fn visit(func: &Function) -> BTreeSet<usize> {
+pub fn visit(ir: &Intermediate) -> BTreeSet<usize> {
 	let mut visit = Visit {
 		result: BTreeSet::new(),
 	};
 
-	func.accept(&mut visit);
+	ir.accept(&mut visit);
 
 	visit.result
 }

codegen-luajit/src/gen.rs

@@ -7,9 +7,9 @@ use parity_wasm::elements::{
 use wasm_ast::{
 	builder::{Builder, TypeInfo},
 	node::{
-		AnyBinOp, AnyCmpOp, AnyLoad, AnyStore, AnyUnOp, Backward, Br, BrIf, BrTable, Call,
-		CallIndirect, Else, Expression, Forward, Function, GetGlobal, GetLocal, If, Memorize,
-		MemoryGrow, MemorySize, Recall, Return, Select, SetGlobal, SetLocal, Statement, Value,
+		Backward, BinOp, Br, BrIf, BrTable, Call, CallIndirect, CmpOp, Else, Expression, Forward,
+		GetGlobal, GetLocal, If, Intermediate, LoadAt, Memorize, MemoryGrow, MemorySize, Recall,
+		Return, Select, SetGlobal, SetLocal, Statement, StoreAt, UnOp, Value,
 	},
 	writer::{Transpiler, Writer},
 };
@@ -109,9 +109,9 @@ fn write_named_array(name: &str, len: usize, w: Writer) -> Result<()> {
 	write!(w, "local {name} = table_new({len}, {hash})")
 }
 
-fn write_parameter_list(func: &Function, w: Writer) -> Result<()> {
+fn write_parameter_list(ir: &Intermediate, w: Writer) -> Result<()> {
 	write!(w, "function(")?;
-	write_ascending("param", 0..func.num_param, w)?;
+	write_ascending("param", 0..ir.num_param, w)?;
 	write!(w, ")")
 }
 
@@ -124,10 +124,10 @@ fn write_call_store(result: Range<usize>, w: Writer) -> Result<()> {
 	write!(w, " = ")
 }
 
-fn write_variable_list(func: &Function, w: Writer) -> Result<()> {
+fn write_variable_list(ir: &Intermediate, w: Writer) -> Result<()> {
 	let mut total = 0;
 
-	for data in &func.local_data {
+	for data in &ir.local_data {
 		let range = total..total + usize::try_from(data.count()).unwrap();
 		let typed = data.value_type();
 
@@ -139,9 +139,9 @@ fn write_variable_list(func: &Function, w: Writer) -> Result<()> {
 		write_separated(range, |_, w| write!(w, "ZERO_{typed} "), w)?;
 	}
 
-	if func.num_stack != 0 {
+	if ir.num_stack != 0 {
 		write!(w, "local ")?;
-		write_ascending("reg", 0..func.num_stack, w)?;
+		write_ascending("reg", 0..ir.num_stack, w)?;
 		write!(w, " ")?;
 	}
 
@@ -252,9 +252,9 @@ impl Driver for GetGlobal {
 	}
 }
 
-impl Driver for AnyLoad {
+impl Driver for LoadAt {
 	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
-		write!(w, "load_{}(memory_at_0, ", self.op.as_name())?;
+		write!(w, "load_{}(memory_at_0, ", self.what.as_name())?;
 		self.pointer.visit(v, w)?;
 		write!(w, "+ {})", self.offset)
 	}
@@ -285,7 +285,7 @@ impl Driver for Value {
 	}
 }
 
-impl Driver for AnyUnOp {
+impl Driver for UnOp {
 	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
 		let (a, b) = self.op.as_name();
 
@@ -309,7 +309,7 @@ fn write_bin_call(
 	write!(w, ")")
 }
 
-impl Driver for AnyBinOp {
+impl Driver for BinOp {
 	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
 		if let Some(op) = self.op.as_operator() {
 			write!(w, "(")?;
@@ -323,7 +323,7 @@ impl Driver for AnyBinOp {
 	}
 }
 
-fn write_any_cmp(cmp: &AnyCmpOp, v: &mut Visitor, w: Writer) -> Result<()> {
+fn write_any_cmp(cmp: &CmpOp, v: &mut Visitor, w: Writer) -> Result<()> {
 	if let Some(op) = cmp.op.as_operator() {
 		cmp.lhs.visit(v, w)?;
 		write!(w, "{op} ")?;
@@ -333,7 +333,7 @@ fn write_any_cmp(cmp: &AnyCmpOp, v: &mut Visitor, w: Writer) -> Result<()> {
 	}
 }
 
-impl Driver for AnyCmpOp {
+impl Driver for CmpOp {
 	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
 		write!(w, "(")?;
 		write_any_cmp(self, v, w)?;
@@ -343,7 +343,7 @@ impl Driver for AnyCmpOp {
 
 // Removes the boolean to integer conversion
 fn write_as_condition(data: &Expression, v: &mut Visitor, w: Writer) -> Result<()> {
-	if let Expression::AnyCmpOp(o) = data {
+	if let Expression::CmpOp(o) = data {
 		write_any_cmp(o, v, w)
 	} else {
 		data.visit(v, w)?;
@@ -362,13 +362,13 @@ impl Driver for Expression {
 			Self::Select(e) => e.visit(v, w),
 			Self::GetLocal(e) => e.visit(v, w),
 			Self::GetGlobal(e) => e.visit(v, w),
-			Self::AnyLoad(e) => e.visit(v, w),
+			Self::LoadAt(e) => e.visit(v, w),
 			Self::MemorySize(e) => e.visit(v, w),
 			Self::MemoryGrow(e) => e.visit(v, w),
 			Self::Value(e) => e.visit(v, w),
-			Self::AnyUnOp(e) => e.visit(v, w),
-			Self::AnyBinOp(e) => e.visit(v, w),
-			Self::AnyCmpOp(e) => e.visit(v, w),
+			Self::UnOp(e) => e.visit(v, w),
+			Self::BinOp(e) => e.visit(v, w),
+			Self::CmpOp(e) => e.visit(v, w),
 		}
 	}
 }
@@ -544,9 +544,9 @@ impl Driver for SetGlobal {
 	}
 }
 
-impl Driver for AnyStore {
+impl Driver for StoreAt {
 	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
-		write!(w, "store_{}(memory_at_0, ", self.op.as_name())?;
+		write!(w, "store_{}(memory_at_0, ", self.what.as_name())?;
 		self.pointer.visit(v, w)?;
 		write!(w, "+ {}, ", self.offset)?;
 		self.value.visit(v, w)?;
@@ -570,12 +570,12 @@ impl Driver for Statement {
 			Self::CallIndirect(s) => s.visit(v, w),
 			Self::SetLocal(s) => s.visit(v, w),
 			Self::SetGlobal(s) => s.visit(v, w),
-			Self::AnyStore(s) => s.visit(v, w),
+			Self::StoreAt(s) => s.visit(v, w),
 		}
 	}
 }
 
-impl Driver for Function {
+impl Driver for Intermediate {
 	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
 		write_parameter_list(self, w)?;
 
@@ -815,7 +815,7 @@ impl<'a> Generator<'a> {
 		write!(w, "}} end ")
 	}
 
-	fn gen_localize(func_list: &[Function], w: Writer) -> Result<()> {
+	fn gen_localize(func_list: &[Intermediate], w: Writer) -> Result<()> {
 		let mut loc_set = BTreeSet::new();
 
 		for func in func_list {
@@ -829,7 +829,7 @@ impl<'a> Generator<'a> {
 
 	// FIXME: Make `pub` only for fuzzing.
 	#[must_use]
-	pub fn build_func_list(&self) -> Vec<Function> {
+	pub fn build_func_list(&self) -> Vec<Intermediate> {
 		let list = self.wasm.code_section().unwrap().bodies();
 		let iter = list.iter().enumerate();
 
@@ -842,7 +842,7 @@ impl<'a> Generator<'a> {
 	///
 	/// # Panics
 	/// If the number of functions overflows 32 bits.
-	pub fn gen_func_list(&self, func_list: &[Function], w: Writer) -> Result<()> {
+	pub fn gen_func_list(&self, func_list: &[Intermediate], w: Writer) -> Result<()> {
 		let offset = self.type_info.len_ex().try_into().unwrap();
 
 		func_list.iter().enumerate().try_for_each(|(i, v)| {