j/Conlang
1
1
Fork 0
Code Issues 5 Pull Requests Packages Projects 2 Releases Wiki Activity

cl-ast: Clean up "to", "extents", Module."kind"

Browse Source
This commit is contained in:
John
2025-03-14 00:52:43 -05:00
parent 11c8daaed0
commit 33e13425a9
13 changed files with 95 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
compiler/cl-ast/src/ast.rs
View File

@@ -62,7 +62,7 @@ pub enum MetaKind {
/// Anything that can appear at the top level of a [File]
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Item {
pub extents: Span,
pub span: Span,
pub attrs: Attrs,
pub vis: Visibility,
pub kind: ItemKind,
@@ -96,13 +96,13 @@ pub enum ItemKind {
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Module {
pub name: Sym,
pub kind: Option<File>,
pub file: Option<File>,
}
/// An alias to another [Ty]
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Alias {
pub to: Sym,
pub name: Sym,
pub from: Option<Box<Ty>>,
}
@@ -212,7 +212,7 @@ pub enum UseTree {
/// A type expression
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Ty {
pub extents: Span,
pub span: Span,
pub kind: TyKind,
}
@@ -283,7 +283,7 @@ pub enum PathPart {
/// An abstract statement, and associated metadata
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Stmt {
pub extents: Span,
pub span: Span,
pub kind: StmtKind,
pub semi: Semi,
}
@@ -306,7 +306,7 @@ pub enum Semi {
/// An expression, the beating heart of the language
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Expr {
pub extents: Span,
pub span: Span,
pub kind: ExprKind,
}

16
compiler/cl-ast/src/ast_impl.rs
View File

@@ -93,7 +93,7 @@ mod display {
impl Display for Item {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Self { extents: _, attrs, vis, kind } = self;
let Self { span: _, attrs, vis, kind } = self;
attrs.fmt(f)?;
vis.fmt(f)?;
kind.fmt(f)
@@ -118,10 +118,10 @@ mod display {
impl Display for Alias {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Self { to, from } = self;
let Self { name, from } = self;
match from {
Some(from) => write!(f, "type {to} = {from};"),
None => write!(f, "type {to};"),
Some(from) => write!(f, "type {name} = {from};"),
None => write!(f, "type {name};"),
}
}
}
@@ -142,9 +142,9 @@ mod display {
impl Display for Module {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Self { name, kind } = self;
let Self { name, file } = self;
write!(f, "mod {name}")?;
match kind {
match file {
Some(items) => {
' '.fmt(f)?;
write!(f.delimit(BRACES), "{items}")
@@ -365,7 +365,7 @@ mod display {
impl Display for Stmt {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Stmt { extents: _, kind, semi } = self;
let Stmt { span: _, kind, semi } = self;
write!(f, "{kind}{semi}")
}
}
@@ -939,7 +939,7 @@ mod path {
/// Checks whether this path refers to the sinkhole identifier, `_`
pub fn is_sinkhole(&self) -> bool {
if let [PathPart::Ident(id)] = self.parts.as_slice() {
if let "_" = id.to_ref(){
if let "_" = id.to_ref() {
return true;
}
}

28
compiler/cl-ast/src/ast_visitor/fold.rs
View File

@@ -13,8 +13,8 @@ use cl_structures::span::Span;
///
/// For all other nodes, traversal is *explicit*.
pub trait Fold {
fn fold_span(&mut self, extents: Span) -> Span {
extents
fn fold_span(&mut self, span: Span) -> Span {
span
}
fn fold_mutability(&mut self, mutability: Mutability) -> Mutability {
mutability
@@ -59,9 +59,9 @@ pub trait Fold {
or_fold_meta_kind(self, kind)
}
fn fold_item(&mut self, i: Item) -> Item {
let Item { extents, attrs, vis, kind } = i;
let Item { span, attrs, vis, kind } = i;
Item {
extents: self.fold_span(extents),
span: self.fold_span(span),
attrs: self.fold_attrs(attrs),
vis: self.fold_visibility(vis),
kind: self.fold_item_kind(kind),
@@ -71,8 +71,8 @@ pub trait Fold {
or_fold_item_kind(self, kind)
}
fn fold_alias(&mut self, a: Alias) -> Alias {
let Alias { to, from } = a;
Alias { to: self.fold_sym(to), from: from.map(|from| Box::new(self.fold_ty(*from))) }
let Alias { name, from } = a;
Alias { name: self.fold_sym(name), from: from.map(|from| Box::new(self.fold_ty(*from))) }
}
fn fold_const(&mut self, c: Const) -> Const {
let Const { name, ty, init } = c;
@@ -92,8 +92,8 @@ pub trait Fold {
}
}
fn fold_module(&mut self, m: Module) -> Module {
let Module { name, kind } = m;
Module { name: self.fold_sym(name), kind: kind.map(|v| self.fold_file(v)) }
let Module { name, file } = m;
Module { name: self.fold_sym(name), file: file.map(|v| self.fold_file(v)) }
}
fn fold_function(&mut self, f: Function) -> Function {
let Function { name, sign, bind, body } = f;
@@ -159,8 +159,8 @@ pub trait Fold {
or_fold_use_tree(self, tree)
}
fn fold_ty(&mut self, t: Ty) -> Ty {
let Ty { extents, kind } = t;
Ty { extents: self.fold_span(extents), kind: self.fold_ty_kind(kind) }
let Ty { span, kind } = t;
Ty { span: self.fold_span(span), kind: self.fold_ty_kind(kind) }
}
fn fold_ty_kind(&mut self, kind: TyKind) -> TyKind {
or_fold_ty_kind(self, kind)
@@ -206,9 +206,9 @@ pub trait Fold {
}
}
fn fold_stmt(&mut self, s: Stmt) -> Stmt {
let Stmt { extents, kind, semi } = s;
let Stmt { span, kind, semi } = s;
Stmt {
extents: self.fold_span(extents),
span: self.fold_span(span),
kind: self.fold_stmt_kind(kind),
semi: self.fold_semi(semi),
}
@@ -220,8 +220,8 @@ pub trait Fold {
s
}
fn fold_expr(&mut self, e: Expr) -> Expr {
let Expr { extents, kind } = e;
Expr { extents: self.fold_span(extents), kind: self.fold_expr_kind(kind) }
let Expr { span, kind } = e;
Expr { span: self.fold_span(span), kind: self.fold_expr_kind(kind) }
}
fn fold_expr_kind(&mut self, kind: ExprKind) -> ExprKind {
or_fold_expr_kind(self, kind)

26
compiler/cl-ast/src/ast_visitor/visit.rs
View File

@@ -13,7 +13,7 @@ use cl_structures::span::Span;
///
/// For all other nodes, traversal is *explicit*.
pub trait Visit<'a>: Sized {
fn visit_span(&mut self, _extents: &'a Span) {}
fn visit_span(&mut self, _span: &'a Span) {}
fn visit_mutability(&mut self, _mutable: &'a Mutability) {}
fn visit_visibility(&mut self, _vis: &'a Visibility) {}
fn visit_sym(&mut self, _name: &'a Sym) {}
@@ -42,8 +42,8 @@ pub trait Visit<'a>: Sized {
or_visit_meta_kind(self, kind)
}
fn visit_item(&mut self, i: &'a Item) {
let Item { extents, attrs, vis, kind } = i;
self.visit_span(extents);
let Item { span, attrs, vis, kind } = i;
self.visit_span(span);
self.visit_attrs(attrs);
self.visit_visibility(vis);
self.visit_item_kind(kind);
@@ -52,8 +52,8 @@ pub trait Visit<'a>: Sized {
or_visit_item_kind(self, kind)
}
fn visit_alias(&mut self, a: &'a Alias) {
let Alias { to, from } = a;
self.visit_sym(to);
let Alias { name, from } = a;
self.visit_sym(name);
if let Some(t) = from {
self.visit_ty(t)
}
@@ -72,9 +72,9 @@ pub trait Visit<'a>: Sized {
self.visit_expr(init);
}
fn visit_module(&mut self, m: &'a Module) {
let Module { name, kind } = m;
let Module { name, file } = m;
self.visit_sym(name);
if let Some(f) = kind {
if let Some(f) = file {
self.visit_file(f)
}
}
@@ -132,8 +132,8 @@ pub trait Visit<'a>: Sized {
or_visit_use_tree(self, tree)
}
fn visit_ty(&mut self, t: &'a Ty) {
let Ty { extents, kind } = t;
self.visit_span(extents);
let Ty { span, kind } = t;
self.visit_span(span);
self.visit_ty_kind(kind);
}
fn visit_ty_kind(&mut self, kind: &'a TyKind) {
@@ -176,8 +176,8 @@ pub trait Visit<'a>: Sized {
}
}
fn visit_stmt(&mut self, s: &'a Stmt) {
let Stmt { extents, kind, semi } = s;
self.visit_span(extents);
let Stmt { span, kind, semi } = s;
self.visit_span(span);
self.visit_stmt_kind(kind);
self.visit_semi(semi);
}
@@ -186,8 +186,8 @@ pub trait Visit<'a>: Sized {
}
fn visit_semi(&mut self, _s: &'a Semi) {}
fn visit_expr(&mut self, e: &'a Expr) {
let Expr { extents, kind } = e;
self.visit_span(extents);
let Expr { span, kind } = e;
self.visit_span(span);
self.visit_expr_kind(kind)
}
fn visit_expr_kind(&mut self, e: &'a ExprKind) {

8
compiler/cl-ast/src/desugar/path_absoluter.rs
View File

@@ -23,14 +23,14 @@ impl Default for NormalizePaths {
impl Fold for NormalizePaths {
fn fold_module(&mut self, m: Module) -> Module {
let Module { name, kind } = m;
let Module { name, file } = m;
self.path.push(PathPart::Ident(name));
let name = self.fold_sym(name);
let kind = kind.map(|f| self.fold_file(f));
let file = file.map(|f| self.fold_file(f));
self.path.pop();
Module { name, kind }
Module { name, file }
}
fn fold_path(&mut self, p: Path) -> Path {

16
compiler/cl-ast/src/desugar/while_else.rs
View File

@@ -10,26 +10,26 @@ pub struct WhileElseDesugar;
impl Fold for WhileElseDesugar {
fn fold_expr(&mut self, e: Expr) -> Expr {
let Expr { extents, kind } = e;
let kind = desugar_while(extents, kind);
Expr { extents: self.fold_span(extents), kind: self.fold_expr_kind(kind) }
let Expr { span, kind } = e;
let kind = desugar_while(span, kind);
Expr { span: self.fold_span(span), kind: self.fold_expr_kind(kind) }
}
}
/// Desugars while(-else) expressions into loop-if-else-break expressions
fn desugar_while(extents: Span, kind: ExprKind) -> ExprKind {
fn desugar_while(span: Span, kind: ExprKind) -> ExprKind {
match kind {
// work backwards: fail -> break -> if -> loop
ExprKind::While(While { cond, pass, fail: Else { body } }) => {
// Preserve the else-expression's extents, if present, or use the parent's extents
let fail_span = body.as_ref().map(|body| body.extents).unwrap_or(extents);
let break_expr = Expr { extents: fail_span, kind: ExprKind::Break(Break { body }) };
// Preserve the else-expression's span, if present, or use the parent's span
let fail_span = body.as_ref().map(|body| body.span).unwrap_or(span);
let break_expr = Expr { span: fail_span, kind: ExprKind::Break(Break { body }) };
let loop_body = If { cond, pass, fail: Else { body: Some(Box::new(break_expr)) } };
let loop_body = ExprKind::If(loop_body);
ExprKind::Unary(Unary {
kind: UnaryKind::Loop,
tail: Box::new(Expr { extents, kind: loop_body }),
tail: Box::new(Expr { span, kind: loop_body }),
})
}
_ => kind,