From 89cf63ebcec1055bf17a48ae6862891121515261 Mon Sep 17 00:00:00 2001
From: Aaron Councilman <aaronjc4@illinois.edu>
Date: Wed, 19 Feb 2025 08:19:51 -0600
Subject: [PATCH] Formatting
---
hercules_ir/src/collections.rs | 2 +
hercules_ir/src/def_use.rs | 10 +---
hercules_ir/src/dot.rs | 5 +-
hercules_ir/src/parse.rs | 11 ++--
hercules_ir/src/typecheck.rs | 11 ++--
juno_frontend/src/codegen.rs | 10 ++--
juno_frontend/src/semant.rs | 100 +++++++++++++++++----------------
juno_frontend/src/types.rs | 8 ++-
8 files changed, 79 insertions(+), 78 deletions(-)
diff --git a/hercules_ir/src/collections.rs b/hercules_ir/src/collections.rs
index c4e71f8b..06a53fdb 100644
--- a/hercules_ir/src/collections.rs
+++ b/hercules_ir/src/collections.rs
@@ -155,6 +155,8 @@ pub fn collection_objects(
typing: &ModuleTyping,
callgraph: &CallGraph,
) -> CollectionObjects {
+ panic!("Collections analysis needs to be updated to handle multi-return");
+
// Analyze functions in reverse topological order, since the analysis of a
// function depends on all functions it calls.
let mut collection_objects: CollectionObjects = BTreeMap::new();
diff --git a/hercules_ir/src/def_use.rs b/hercules_ir/src/def_use.rs
index 99531345..e9ba4576 100644
--- a/hercules_ir/src/def_use.rs
+++ b/hercules_ir/src/def_use.rs
@@ -230,10 +230,7 @@ pub fn get_uses(node: &Node) -> NodeUses {
control,
selection: _,
} => NodeUses::One([*control]),
- Node::DataProjection {
- data,
- selection: _,
- } => NodeUses::One([*data]),
+ Node::DataProjection { data, selection: _ } => NodeUses::One([*data]),
Node::Undef { ty: _ } => NodeUses::One([NodeID::new(0)]),
}
}
@@ -340,10 +337,7 @@ pub fn get_uses_mut<'a>(node: &'a mut Node) -> NodeUsesMut<'a> {
control,
selection: _,
} => NodeUsesMut::One([control]),
- Node::DataProjection {
- data,
- selection: _,
- } => NodeUsesMut::One([data]),
+ Node::DataProjection { data, selection: _ } => NodeUsesMut::One([data]),
Node::Undef { ty: _ } => NodeUsesMut::Zero,
}
}
diff --git a/hercules_ir/src/dot.rs b/hercules_ir/src/dot.rs
index a7f890f8..aff1f9c5 100644
--- a/hercules_ir/src/dot.rs
+++ b/hercules_ir/src/dot.rs
@@ -353,10 +353,7 @@ fn write_node<W: Write>(
control: _,
selection,
}
- | Node::DataProjection {
- data: _,
- selection,
- } => write!(&mut suffix, "{}", selection)?,
+ | Node::DataProjection { data: _, selection } => write!(&mut suffix, "{}", selection)?,
_ => {}
};
diff --git a/hercules_ir/src/parse.rs b/hercules_ir/src/parse.rs
index 42730f77..b41b1f6f 100644
--- a/hercules_ir/src/parse.rs
+++ b/hercules_ir/src/parse.rs
@@ -509,9 +509,13 @@ fn parse_return<'a>(
nom::character::complete::char(','),
nom::character::complete::multispace0,
)),
- parse_identifier)(ir_text)?;
+ parse_identifier,
+ )(ir_text)?;
let control = context.borrow_mut().get_node_id(control);
- let data = data.into_iter().map(|d| context.borrow_mut().get_node_id(d)).collect();
+ let data = data
+ .into_iter()
+ .map(|d| context.borrow_mut().get_node_id(d))
+ .collect();
Ok((ir_text, Node::Return { control, data }))
}
@@ -1027,8 +1031,7 @@ fn parse_constant<'a>(
) -> nom::IResult<&'a str, Constant> {
let (ir_text, constant) = match ty {
// There are not control constants.
- Type::Control
- | Type::MultiReturn(_) => Err(nom::Err::Error(nom::error::Error {
+ Type::Control | Type::MultiReturn(_) => Err(nom::Err::Error(nom::error::Error {
input: ir_text,
code: nom::error::ErrorKind::IsNot,
}))?,
diff --git a/hercules_ir/src/typecheck.rs b/hercules_ir/src/typecheck.rs
index 919da640..2a3f9fb1 100644
--- a/hercules_ir/src/typecheck.rs
+++ b/hercules_ir/src/typecheck.rs
@@ -441,7 +441,11 @@ fn typeflow(
return inputs[0].clone();
}
- for (idx, (input, return_type)) in inputs[1..].iter().zip(function.return_types.iter()).enumerate() {
+ for (idx, (input, return_type)) in inputs[1..]
+ .iter()
+ .zip(function.return_types.iter())
+ .enumerate()
+ {
if let Concrete(id) = input {
if *id != *return_type {
return Error(format!("Return node's data input at index {} does not match function's return type.", idx));
@@ -1070,10 +1074,7 @@ fn typeflow(
// Type is the type of the _if node
inputs[0].clone()
}
- Node::DataProjection {
- data: _,
- selection,
- } => {
+ Node::DataProjection { data: _, selection } => {
if let Concrete(type_id) = inputs[0] {
match &types[type_id.idx()] {
Type::MultiReturn(types) => {
diff --git a/juno_frontend/src/codegen.rs b/juno_frontend/src/codegen.rs
index 533fd268..0902bc61 100644
--- a/juno_frontend/src/codegen.rs
+++ b/juno_frontend/src/codegen.rs
@@ -118,11 +118,11 @@ impl CodeGenerator<'_> {
param_types.push(solver_inst.lower_type(&mut self.builder.builder, *ty));
}
- let return_types =
- func.return_types
- .iter()
- .map(|t| solver_inst.lower_type(&mut self.builder.builder, *t))
- .collect::<Vec<_>>();
+ let return_types = func
+ .return_types
+ .iter()
+ .map(|t| solver_inst.lower_type(&mut self.builder.builder, *t))
+ .collect::<Vec<_>>();
let (func_id, entry) = self
.builder
diff --git a/juno_frontend/src/semant.rs b/juno_frontend/src/semant.rs
index ae696b4f..f0736d2b 100644
--- a/juno_frontend/src/semant.rs
+++ b/juno_frontend/src/semant.rs
@@ -751,7 +751,7 @@ fn analyze_program(
let return_types = rets
.into_iter()
- .map(|ty|
+ .map(|ty| {
match process_type(
ty,
num_dyn_const,
@@ -769,7 +769,7 @@ fn analyze_program(
types.new_primitive(types::Primitive::Unit)
}
}
- )
+ })
.collect::<Vec<_>>();
if !errors.is_empty() {
@@ -778,7 +778,11 @@ fn analyze_program(
// Compute the proper type accounting for the inouts (which become returns)
let inout_types = inouts.iter().map(|e| e.get_type()).collect::<Vec<_>>();
- let pure_return_types = return_types.clone().into_iter().chain(inout_types.into_iter()).collect::<Vec<_>>();
+ let pure_return_types = return_types
+ .clone()
+ .into_iter()
+ .chain(inout_types.into_iter())
+ .collect::<Vec<_>>();
// Finally, we have a properly built environment and we can
// start processing the body
@@ -802,13 +806,7 @@ fn analyze_program(
if return_types.is_empty() {
// Insert return at the end
body = Stmt::BlockStmt {
- body: vec![
- body,
- generate_return(
- vec![],
- &inouts,
- ),
- ],
+ body: vec![body, generate_return(vec![], &inouts)],
};
} else {
Err(singleton_error(ErrorMessage::SemanticError(
@@ -1574,16 +1572,11 @@ fn process_stmt(
labels: &mut StringTable,
) -> Result<(Stmt, bool), ErrorMessages> {
match stmt {
- parser::Stmt::LetStmt {
- span,
- var,
- init,
- } => {
- let (_, pattern, typ) =
- match var {
- LetBind::Single { span, pattern, typ } => (span, Either::Left(pattern), typ),
- LetBind::Multi { span, patterns } => (span, Either::Right(patterns), None),
- };
+ parser::Stmt::LetStmt { span, var, init } => {
+ let (_, pattern, typ) = match var {
+ LetBind::Single { span, pattern, typ } => (span, Either::Left(pattern), typ),
+ LetBind::Multi { span, patterns } => (span, Either::Right(patterns), None),
+ };
if typ.is_none() && init.is_none() {
return Err(singleton_error(ErrorMessage::SemanticError(
@@ -1662,15 +1655,20 @@ fn process_stmt(
if return_types.len() != patterns.len() {
return Err(singleton_error(ErrorMessage::SemanticError(
span_to_loc(span, lexer),
- format!("Expected {} pattern, found {} patterns", return_types.len(), patterns.len()),
+ format!(
+ "Expected {} pattern, found {} patterns",
+ return_types.len(),
+ patterns.len()
+ ),
)));
}
// Process each pattern after extracting the appropriate value from the call
- for (index, (pat, ret_typ)) in
- patterns.into_iter()
- .zip(return_types.clone().into_iter())
- .enumerate() {
+ for (index, (pat, ret_typ)) in patterns
+ .into_iter()
+ .zip(return_types.clone().into_iter())
+ .enumerate()
+ {
let extract_var = env.uniq();
res.push(Stmt::AssignStmt {
var: extract_var,
@@ -1678,11 +1676,19 @@ fn process_stmt(
call: Box::new(Expr::Variable { var, typ }),
index,
typ: ret_typ,
- }
+ },
});
res.extend(
process_irrefutable_pattern(
- pat, false, extract_var, ret_typ, lexer, stringtab, env, types, false
+ pat,
+ false,
+ extract_var,
+ ret_typ,
+ lexer,
+ stringtab,
+ env,
+ types,
+ false,
)?
.0,
);
@@ -1690,7 +1696,6 @@ fn process_stmt(
}
}
-
Ok((Stmt::BlockStmt { body: res }, true))
}
parser::Stmt::ConstStmt {
@@ -2257,7 +2262,8 @@ fn process_stmt(
"Expected {} return values found {}",
return_types.len(),
vals.len(),
- ))));
+ ),
+ )));
}
let return_vals = vals
@@ -2276,20 +2282,17 @@ fn process_stmt(
)))
}
})
- .fold(Ok(vec![]),
- |res, val| {
- match (res, val) {
- (Ok(mut res), Ok(val)) => {
- res.push(val);
- Ok(res)
- }
- (Ok(_), Err(msg)) => Err(msg),
- (Err(msg), Ok(_)) => Err(msg),
- (Err(mut msgs), Err(msg)) => {
- msgs.extend(msg);
- Err(msgs)
- }
- }
+ .fold(Ok(vec![]), |res, val| match (res, val) {
+ (Ok(mut res), Ok(val)) => {
+ res.push(val);
+ Ok(res)
+ }
+ (Ok(_), Err(msg)) => Err(msg),
+ (Err(msg), Ok(_)) => Err(msg),
+ (Err(mut msgs), Err(msg)) => {
+ msgs.extend(msg);
+ Err(msgs)
+ }
})?;
// We return both the actual return values and the inout arguments
@@ -4911,12 +4914,11 @@ fn process_expr(
if !errors.is_empty() {
Err(errors)
} else {
- let single_type =
- if return_types.len() == 1 {
- Some(return_types[0])
- } else {
- None
- };
+ let single_type = if return_types.len() == 1 {
+ Some(return_types[0])
+ } else {
+ None
+ };
let num_returns = return_types.len();
let call = Expr::CallExpr {
func,
diff --git a/juno_frontend/src/types.rs b/juno_frontend/src/types.rs
index 6e59169d..4099c567 100644
--- a/juno_frontend/src/types.rs
+++ b/juno_frontend/src/types.rs
@@ -555,7 +555,6 @@ impl TypeSolver {
// Note that MultReturn types never unify with anything (even itself), this is
// intentional and makes it so that the only way MultiReturns can be used is to
// destruct them
-
_ => false,
}
}
@@ -707,8 +706,11 @@ impl TypeSolver {
| TypeForm::Struct { name, .. }
| TypeForm::Union { name, .. } => stringtab(*name),
TypeForm::AnyOfKind { kind, .. } => kind.to_string(),
- TypeForm::MultiReturn { types } =>
- types.iter().map(|t| self.to_string(*t, stringtab)).collect::<Vec<_>>().join(", "),
+ TypeForm::MultiReturn { types } => types
+ .iter()
+ .map(|t| self.to_string(*t, stringtab))
+ .collect::<Vec<_>>()
+ .join(", "),
}
}
--
GitLab