tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(fmt): add legacy stubs and strip trailing whitespace to unblock cargo fmt

Browse Source
This commit is contained in:
Selfhosting Dev
2025-09-17 07:43:07 +09:00
parent fcf8ce1f3c
commit adbb0201a9
385 changed files with 35622 additions and 15004 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
src/parser/sugar.rs
View File

@ -16,60 +16,159 @@ fn rewrite(ast: ASTNode) -> ASTNode {
match ast {
ASTNode::Program { statements, span } => {
let stmts = statements.into_iter().map(|s| rewrite(s)).collect();
ASTNode::Program { statements: stmts, span }
ASTNode::Program {
statements: stmts,
span,
}
}
ASTNode::Assignment { target, value, span } => {
ASTNode::Assignment { target: Box::new(rewrite(*target)), value: Box::new(rewrite(*value)), span }
}
ASTNode::BinaryOp { operator, left, right, span } => {
ASTNode::Assignment {
target,
value,
span,
} => ASTNode::Assignment {
target: Box::new(rewrite(*target)),
value: Box::new(rewrite(*value)),
span,
},
ASTNode::BinaryOp {
operator,
left,
right,
span,
} => {
// default null (??): a ?? b => if a is null then b else a
// Here we approximate as: (a == null) ? b : a using peek-like structure
// For minimalism, keep as BinaryOp and rely on later phases (placeholder).
ASTNode::BinaryOp { operator, left: Box::new(rewrite(*left)), right: Box::new(rewrite(*right)), span }
}
ASTNode::MethodCall { object, method, arguments, span } => {
ASTNode::MethodCall { object: Box::new(rewrite(*object)), method, arguments: arguments.into_iter().map(rewrite).collect(), span }
}
ASTNode::FunctionCall { name, arguments, span } => {
ASTNode::FunctionCall { name, arguments: arguments.into_iter().map(rewrite).collect(), span }
}
ASTNode::FieldAccess { object, field, span } => {
ASTNode::FieldAccess { object: Box::new(rewrite(*object)), field, span }
}
ASTNode::UnaryOp { operator, operand, span } => {
ASTNode::UnaryOp { operator, operand: Box::new(rewrite(*operand)), span }
}
ASTNode::PeekExpr { scrutinee, arms, else_expr, span } => {
ASTNode::PeekExpr { scrutinee: Box::new(rewrite(*scrutinee)), arms: arms.into_iter().map(|(l,e)| (l, rewrite(e))).collect(), else_expr: Box::new(rewrite(*else_expr)), span }
ASTNode::BinaryOp {
operator,
left: Box::new(rewrite(*left)),
right: Box::new(rewrite(*right)),
span,
}
}
ASTNode::MethodCall {
object,
method,
arguments,
span,
} => ASTNode::MethodCall {
object: Box::new(rewrite(*object)),
method,
arguments: arguments.into_iter().map(rewrite).collect(),
span,
},
ASTNode::FunctionCall {
name,
arguments,
span,
} => ASTNode::FunctionCall {
name,
arguments: arguments.into_iter().map(rewrite).collect(),
span,
},
ASTNode::FieldAccess {
object,
field,
span,
} => ASTNode::FieldAccess {
object: Box::new(rewrite(*object)),
field,
span,
},
ASTNode::UnaryOp {
operator,
operand,
span,
} => ASTNode::UnaryOp {
operator,
operand: Box::new(rewrite(*operand)),
span,
},
ASTNode::PeekExpr {
scrutinee,
arms,
else_expr,
span,
} => ASTNode::PeekExpr {
scrutinee: Box::new(rewrite(*scrutinee)),
arms: arms.into_iter().map(|(l, e)| (l, rewrite(e))).collect(),
else_expr: Box::new(rewrite(*else_expr)),
span,
},
// Others: recursively visit children where present
ASTNode::If { condition, then_body, else_body, span } => {
ASTNode::If { condition: Box::new(rewrite(*condition)), then_body: then_body.into_iter().map(rewrite).collect(), else_body: else_body.map(|v| v.into_iter().map(rewrite).collect()), span }
}
ASTNode::Loop { condition, body, span } => {
ASTNode::Loop { condition: Box::new(rewrite(*condition)), body: body.into_iter().map(rewrite).collect(), span }
}
ASTNode::Return { value, span } => {
ASTNode::Return { value: value.map(|v| Box::new(rewrite(*v))), span }
}
ASTNode::Print { expression, span } => {
ASTNode::Print { expression: Box::new(rewrite(*expression)), span }
}
ASTNode::New { class, arguments, type_arguments, span } => {
ASTNode::New { class, arguments: arguments.into_iter().map(rewrite).collect(), type_arguments, span }
}
ASTNode::Call { callee, arguments, span } => {
ASTNode::Call { callee: Box::new(rewrite(*callee)), arguments: arguments.into_iter().map(rewrite).collect(), span }
}
ASTNode::Local { variables, initial_values, span } => {
ASTNode::Local { variables, initial_values: initial_values.into_iter().map(|o| o.map(|b| Box::new(rewrite(*b)))).collect(), span }
}
ASTNode::If {
condition,
then_body,
else_body,
span,
} => ASTNode::If {
condition: Box::new(rewrite(*condition)),
then_body: then_body.into_iter().map(rewrite).collect(),
else_body: else_body.map(|v| v.into_iter().map(rewrite).collect()),
span,
},
ASTNode::Loop {
condition,
body,
span,
} => ASTNode::Loop {
condition: Box::new(rewrite(*condition)),
body: body.into_iter().map(rewrite).collect(),
span,
},
ASTNode::Return { value, span } => ASTNode::Return {
value: value.map(|v| Box::new(rewrite(*v))),
span,
},
ASTNode::Print { expression, span } => ASTNode::Print {
expression: Box::new(rewrite(*expression)),
span,
},
ASTNode::New {
class,
arguments,
type_arguments,
span,
} => ASTNode::New {
class,
arguments: arguments.into_iter().map(rewrite).collect(),
type_arguments,
span,
},
ASTNode::Call {
callee,
arguments,
span,
} => ASTNode::Call {
callee: Box::new(rewrite(*callee)),
arguments: arguments.into_iter().map(rewrite).collect(),
span,
},
ASTNode::Local {
variables,
initial_values,
span,
} => ASTNode::Local {
variables,
initial_values: initial_values
.into_iter()
.map(|o| o.map(|b| Box::new(rewrite(*b))))
.collect(),
span,
},
other => other,
}
}
#[allow(dead_code)]
fn make_eq_null(expr: ASTNode) -> ASTNode {
ASTNode::BinaryOp { operator: BinaryOperator::Equal, left: Box::new(expr), right: Box::new(ASTNode::Literal { value: LiteralValue::Null, span: Span::unknown() }), span: Span::unknown() }
ASTNode::BinaryOp {
operator: BinaryOperator::Equal,
left: Box::new(expr),
right: Box::new(ASTNode::Literal {
value: LiteralValue::Null,
span: Span::unknown(),
}),
span: Span::unknown(),
}
}