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

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

@ -93,7 +93,7 @@ mod display {
impl Display for Item { impl Display for Item {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 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)?; attrs.fmt(f)?;
vis.fmt(f)?; vis.fmt(f)?;
kind.fmt(f) kind.fmt(f)
@ -118,10 +118,10 @@ mod display {
impl Display for Alias { impl Display for Alias {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Self { to, from } = self; let Self { name, from } = self;
match from { match from {
Some(from) => write!(f, "type {to} = {from};"), Some(from) => write!(f, "type {name} = {from};"),
None => write!(f, "type {to};"), None => write!(f, "type {name};"),
} }
} }
} }
@ -142,9 +142,9 @@ mod display {
impl Display for Module { impl Display for Module {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 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}")?; write!(f, "mod {name}")?;
match kind { match file {
Some(items) => { Some(items) => {
' '.fmt(f)?; ' '.fmt(f)?;
write!(f.delimit(BRACES), "{items}") write!(f.delimit(BRACES), "{items}")
@ -365,7 +365,7 @@ mod display {
impl Display for Stmt { impl Display for Stmt {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 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}") write!(f, "{kind}{semi}")
} }
} }
@ -939,7 +939,7 @@ mod path {
/// Checks whether this path refers to the sinkhole identifier, `_` /// Checks whether this path refers to the sinkhole identifier, `_`
pub fn is_sinkhole(&self) -> bool { pub fn is_sinkhole(&self) -> bool {
if let [PathPart::Ident(id)] = self.parts.as_slice() { if let [PathPart::Ident(id)] = self.parts.as_slice() {
if let "_" = id.to_ref(){ if let "_" = id.to_ref() {
return true; 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*. /// For all other nodes, traversal is *explicit*.
pub trait Fold { pub trait Fold {
fn fold_span(&mut self, extents: Span) -> Span { fn fold_span(&mut self, span: Span) -> Span {
extents span
} }
fn fold_mutability(&mut self, mutability: Mutability) -> Mutability { fn fold_mutability(&mut self, mutability: Mutability) -> Mutability {
mutability mutability
@ -59,9 +59,9 @@ pub trait Fold {
or_fold_meta_kind(self, kind) or_fold_meta_kind(self, kind)
} }
fn fold_item(&mut self, i: Item) -> Item { fn fold_item(&mut self, i: Item) -> Item {
let Item { extents, attrs, vis, kind } = i; let Item { span, attrs, vis, kind } = i;
Item { Item {
extents: self.fold_span(extents), span: self.fold_span(span),
attrs: self.fold_attrs(attrs), attrs: self.fold_attrs(attrs),
vis: self.fold_visibility(vis), vis: self.fold_visibility(vis),
kind: self.fold_item_kind(kind), kind: self.fold_item_kind(kind),
@ -71,8 +71,8 @@ pub trait Fold {
or_fold_item_kind(self, kind) or_fold_item_kind(self, kind)
} }
fn fold_alias(&mut self, a: Alias) -> Alias { fn fold_alias(&mut self, a: Alias) -> Alias {
let Alias { to, from } = a; let Alias { name, from } = a;
Alias { to: self.fold_sym(to), from: from.map(|from| Box::new(self.fold_ty(*from))) } Alias { name: self.fold_sym(name), from: from.map(|from| Box::new(self.fold_ty(*from))) }
} }
fn fold_const(&mut self, c: Const) -> Const { fn fold_const(&mut self, c: Const) -> Const {
let Const { name, ty, init } = c; let Const { name, ty, init } = c;
@ -92,8 +92,8 @@ pub trait Fold {
} }
} }
fn fold_module(&mut self, m: Module) -> Module { fn fold_module(&mut self, m: Module) -> Module {
let Module { name, kind } = m; let Module { name, file } = m;
Module { name: self.fold_sym(name), kind: kind.map(|v| self.fold_file(v)) } Module { name: self.fold_sym(name), file: file.map(|v| self.fold_file(v)) }
} }
fn fold_function(&mut self, f: Function) -> Function { fn fold_function(&mut self, f: Function) -> Function {
let Function { name, sign, bind, body } = f; let Function { name, sign, bind, body } = f;
@ -159,8 +159,8 @@ pub trait Fold {
or_fold_use_tree(self, tree) or_fold_use_tree(self, tree)
} }
fn fold_ty(&mut self, t: Ty) -> Ty { fn fold_ty(&mut self, t: Ty) -> Ty {
let Ty { extents, kind } = t; let Ty { span, kind } = t;
Ty { extents: self.fold_span(extents), kind: self.fold_ty_kind(kind) } Ty { span: self.fold_span(span), kind: self.fold_ty_kind(kind) }
} }
fn fold_ty_kind(&mut self, kind: TyKind) -> TyKind { fn fold_ty_kind(&mut self, kind: TyKind) -> TyKind {
or_fold_ty_kind(self, kind) or_fold_ty_kind(self, kind)
@ -206,9 +206,9 @@ pub trait Fold {
} }
} }
fn fold_stmt(&mut self, s: Stmt) -> Stmt { fn fold_stmt(&mut self, s: Stmt) -> Stmt {
let Stmt { extents, kind, semi } = s; let Stmt { span, kind, semi } = s;
Stmt { Stmt {
extents: self.fold_span(extents), span: self.fold_span(span),
kind: self.fold_stmt_kind(kind), kind: self.fold_stmt_kind(kind),
semi: self.fold_semi(semi), semi: self.fold_semi(semi),
} }
@ -220,8 +220,8 @@ pub trait Fold {
s s
} }
fn fold_expr(&mut self, e: Expr) -> Expr { fn fold_expr(&mut self, e: Expr) -> Expr {
let Expr { extents, kind } = e; let Expr { span, kind } = e;
Expr { extents: self.fold_span(extents), kind: self.fold_expr_kind(kind) } Expr { span: self.fold_span(span), kind: self.fold_expr_kind(kind) }
} }
fn fold_expr_kind(&mut self, kind: ExprKind) -> ExprKind { fn fold_expr_kind(&mut self, kind: ExprKind) -> ExprKind {
or_fold_expr_kind(self, kind) 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*. /// For all other nodes, traversal is *explicit*.
pub trait Visit<'a>: Sized { 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_mutability(&mut self, _mutable: &'a Mutability) {}
fn visit_visibility(&mut self, _vis: &'a Visibility) {} fn visit_visibility(&mut self, _vis: &'a Visibility) {}
fn visit_sym(&mut self, _name: &'a Sym) {} fn visit_sym(&mut self, _name: &'a Sym) {}
@ -42,8 +42,8 @@ pub trait Visit<'a>: Sized {
or_visit_meta_kind(self, kind) or_visit_meta_kind(self, kind)
} }
fn visit_item(&mut self, i: &'a Item) { fn visit_item(&mut self, i: &'a Item) {
let Item { extents, attrs, vis, kind } = i; let Item { span, attrs, vis, kind } = i;
self.visit_span(extents); self.visit_span(span);
self.visit_attrs(attrs); self.visit_attrs(attrs);
self.visit_visibility(vis); self.visit_visibility(vis);
self.visit_item_kind(kind); self.visit_item_kind(kind);
@ -52,8 +52,8 @@ pub trait Visit<'a>: Sized {
or_visit_item_kind(self, kind) or_visit_item_kind(self, kind)
} }
fn visit_alias(&mut self, a: &'a Alias) { fn visit_alias(&mut self, a: &'a Alias) {
let Alias { to, from } = a; let Alias { name, from } = a;
self.visit_sym(to); self.visit_sym(name);
if let Some(t) = from { if let Some(t) = from {
self.visit_ty(t) self.visit_ty(t)
} }
@ -72,9 +72,9 @@ pub trait Visit<'a>: Sized {
self.visit_expr(init); self.visit_expr(init);
} }
fn visit_module(&mut self, m: &'a Module) { fn visit_module(&mut self, m: &'a Module) {
let Module { name, kind } = m; let Module { name, file } = m;
self.visit_sym(name); self.visit_sym(name);
if let Some(f) = kind { if let Some(f) = file {
self.visit_file(f) self.visit_file(f)
} }
} }
@ -132,8 +132,8 @@ pub trait Visit<'a>: Sized {
or_visit_use_tree(self, tree) or_visit_use_tree(self, tree)
} }
fn visit_ty(&mut self, t: &'a Ty) { fn visit_ty(&mut self, t: &'a Ty) {
let Ty { extents, kind } = t; let Ty { span, kind } = t;
self.visit_span(extents); self.visit_span(span);
self.visit_ty_kind(kind); self.visit_ty_kind(kind);
} }
fn visit_ty_kind(&mut self, kind: &'a TyKind) { 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) { fn visit_stmt(&mut self, s: &'a Stmt) {
let Stmt { extents, kind, semi } = s; let Stmt { span, kind, semi } = s;
self.visit_span(extents); self.visit_span(span);
self.visit_stmt_kind(kind); self.visit_stmt_kind(kind);
self.visit_semi(semi); self.visit_semi(semi);
} }
@ -186,8 +186,8 @@ pub trait Visit<'a>: Sized {
} }
fn visit_semi(&mut self, _s: &'a Semi) {} fn visit_semi(&mut self, _s: &'a Semi) {}
fn visit_expr(&mut self, e: &'a Expr) { fn visit_expr(&mut self, e: &'a Expr) {
let Expr { extents, kind } = e; let Expr { span, kind } = e;
self.visit_span(extents); self.visit_span(span);
self.visit_expr_kind(kind) self.visit_expr_kind(kind)
} }
fn visit_expr_kind(&mut self, e: &'a ExprKind) { 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 { impl Fold for NormalizePaths {
fn fold_module(&mut self, m: Module) -> Module { fn fold_module(&mut self, m: Module) -> Module {
let Module { name, kind } = m; let Module { name, file } = m;
self.path.push(PathPart::Ident(name)); self.path.push(PathPart::Ident(name));
let name = self.fold_sym(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(); self.path.pop();
Module { name, kind } Module { name, file }
} }
fn fold_path(&mut self, p: Path) -> Path { 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 { impl Fold for WhileElseDesugar {
fn fold_expr(&mut self, e: Expr) -> Expr { fn fold_expr(&mut self, e: Expr) -> Expr {
let Expr { extents, kind } = e; let Expr { span, kind } = e;
let kind = desugar_while(extents, kind); let kind = desugar_while(span, kind);
Expr { extents: self.fold_span(extents), kind: self.fold_expr_kind(kind) } Expr { span: self.fold_span(span), kind: self.fold_expr_kind(kind) }
} }
} }
/// Desugars while(-else) expressions into loop-if-else-break expressions /// 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 { match kind {
// work backwards: fail -> break -> if -> loop // work backwards: fail -> break -> if -> loop
ExprKind::While(While { cond, pass, fail: Else { body } }) => { ExprKind::While(While { cond, pass, fail: Else { body } }) => {
// Preserve the else-expression's extents, if present, or use the parent's extents // Preserve the else-expression's span, if present, or use the parent's span
let fail_span = body.as_ref().map(|body| body.extents).unwrap_or(extents); let fail_span = body.as_ref().map(|body| body.span).unwrap_or(span);
let break_expr = Expr { extents: fail_span, kind: ExprKind::Break(Break { body }) }; 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 = If { cond, pass, fail: Else { body: Some(Box::new(break_expr)) } };
let loop_body = ExprKind::If(loop_body); let loop_body = ExprKind::If(loop_body);
ExprKind::Unary(Unary { ExprKind::Unary(Unary {
kind: UnaryKind::Loop, kind: UnaryKind::Loop,
tail: Box::new(Expr { extents, kind: loop_body }), tail: Box::new(Expr { span, kind: loop_body }),
}) })
} }
_ => kind, _ => kind,

18
compiler/cl-interpret/src/interpret.rs
View File

@ -87,9 +87,9 @@ impl Interpret for Static {
impl Interpret for Module { impl Interpret for Module {
// TODO: Keep modules around somehow, rather than putting them on the stack // TODO: Keep modules around somehow, rather than putting them on the stack
fn interpret(&self, env: &mut Environment) -> IResult<ConValue> { fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
let Self { name, kind } = self; let Self { name, file } = self;
env.push_frame(name.to_ref(), Default::default()); env.push_frame(name.to_ref(), Default::default());
let out = match kind { let out = match file {
Some(file) => file.interpret(env), Some(file) => file.interpret(env),
None => { None => {
eprintln!("Module {name} specified, but not imported."); eprintln!("Module {name} specified, but not imported.");
@ -128,7 +128,7 @@ impl Interpret for Struct {
.into(), .into(),
rety: Some( rety: Some(
Ty { Ty {
extents: cl_structures::span::Span::dummy(), span: cl_structures::span::Span::dummy(),
kind: TyKind::Path(Path::from(*name)), kind: TyKind::Path(Path::from(*name)),
} }
.into(), .into(),
@ -172,7 +172,7 @@ impl Interpret for Enum {
} }
impl Interpret for Impl { impl Interpret for Impl {
fn interpret(&self, env: &mut Environment) -> IResult<ConValue> { fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
let Self { target: ImplKind::Type(Ty { extents, kind: TyKind::Path(name) }), body } = self let Self { target: ImplKind::Type(Ty { span, kind: TyKind::Path(name) }), body } = self
else { else {
eprintln!("TODO: impl X for Ty"); eprintln!("TODO: impl X for Ty");
return Ok(ConValue::Empty); return Ok(ConValue::Empty);
@ -184,7 +184,7 @@ impl Interpret for Impl {
.pop_frame() .pop_frame()
.expect("Environment frames must be balanced"); .expect("Environment frames must be balanced");
match assignment::addrof_path(env, name.parts.as_slice()) match assignment::addrof_path(env, name.parts.as_slice())
.map_err(|err| err.with_span(*extents))? .map_err(|err| err.with_span(*span))?
{ {
Some(ConValue::Module(m)) => m.extend(frame), Some(ConValue::Module(m)) => m.extend(frame),
Some(other) => eprintln!("TODO: impl for {other}"), Some(other) => eprintln!("TODO: impl for {other}"),
@ -263,13 +263,13 @@ impl Interpret for UseTree {
impl Interpret for Stmt { impl Interpret for Stmt {
fn interpret(&self, env: &mut Environment) -> IResult<ConValue> { fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
let Self { extents, kind, semi } = self; let Self { span, kind, semi } = self;
let out = match kind { let out = match kind {
StmtKind::Empty => Ok(ConValue::Empty), StmtKind::Empty => Ok(ConValue::Empty),
StmtKind::Item(stmt) => stmt.interpret(env), StmtKind::Item(stmt) => stmt.interpret(env),
StmtKind::Expr(stmt) => stmt.interpret(env), StmtKind::Expr(stmt) => stmt.interpret(env),
} }
.map_err(|err| err.with_span(*extents))?; .map_err(|err| err.with_span(*span))?;
Ok(match semi { Ok(match semi {
Semi::Terminated => ConValue::Empty, Semi::Terminated => ConValue::Empty,
Semi::Unterminated => out, Semi::Unterminated => out,
@ -280,8 +280,8 @@ impl Interpret for Stmt {
impl Interpret for Expr { impl Interpret for Expr {
#[inline] #[inline]
fn interpret(&self, env: &mut Environment) -> IResult<ConValue> { fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
let Self { extents, kind } = self; let Self { span, kind } = self;
kind.interpret(env).map_err(|err| err.with_span(*extents)) kind.interpret(env).map_err(|err| err.with_span(*span))
} }
} }

6
compiler/cl-parser/src/inliner.rs
View File

@ -63,13 +63,13 @@ impl ModuleInliner {
impl Fold for ModuleInliner { impl Fold for ModuleInliner {
/// Traverses down the module tree, entering ever nested directories /// Traverses down the module tree, entering ever nested directories
fn fold_module(&mut self, m: Module) -> Module { fn fold_module(&mut self, m: Module) -> Module {
let Module { name, kind } = m; let Module { name, file } = m;
self.path.push(&*name); // cd ./name self.path.push(&*name); // cd ./name
let kind = self.fold_module_kind(kind); let file = self.fold_module_kind(file);
self.path.pop(); // cd .. self.path.pop(); // cd ..
Module { name, kind } Module { name, file }
} }
} }

14
compiler/cl-parser/src/parser.rs
View File

@ -320,7 +320,7 @@ impl Parse<'_> for Item {
attrs: Attrs::parse(p)?, attrs: Attrs::parse(p)?,
vis: Visibility::parse(p)?, vis: Visibility::parse(p)?,
kind: ItemKind::parse(p)?, kind: ItemKind::parse(p)?,
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}) })
} }
} }
@ -352,7 +352,7 @@ impl Parse<'_> for Alias {
p.consume_peeked(); p.consume_peeked();
let out = Ok(Alias { let out = Ok(Alias {
to: Sym::parse(p)?, name: Sym::parse(p)?,
from: if p.match_type(TokenKind::Eq, P).is_ok() { from: if p.match_type(TokenKind::Eq, P).is_ok() {
Some(Ty::parse(p)?.into()) Some(Ty::parse(p)?.into())
} else { } else {
@ -416,7 +416,7 @@ impl Parse<'_> for Module {
Ok(Module { Ok(Module {
name: Sym::parse(p)?, name: Sym::parse(p)?,
kind: { file: {
const P: Parsing = Parsing::ModuleKind; const P: Parsing = Parsing::ModuleKind;
let inline = delim(Parse::parse, CURLIES, P); let inline = delim(Parse::parse, CURLIES, P);
@ -636,7 +636,7 @@ impl Parse<'_> for ImplKind {
Err(Error { Err(Error {
reason: ExpectedParsing { want: Parsing::Path }, reason: ExpectedParsing { want: Parsing::Path },
while_parsing: P, while_parsing: P,
loc: target.extents.head, loc: target.span.head,
})? })?
} }
} }
@ -696,7 +696,7 @@ impl Parse<'_> for Ty {
/// See also: [TyKind::parse] /// See also: [TyKind::parse]
fn parse(p: &mut Parser<'_>) -> PResult<Self> { fn parse(p: &mut Parser<'_>) -> PResult<Self> {
let start = p.loc(); let start = p.loc();
Ok(Ty { kind: TyKind::parse(p)?, extents: Span(start, p.loc()) }) Ok(Ty { kind: TyKind::parse(p)?, span: Span(start, p.loc()) })
} }
} }
@ -868,7 +868,7 @@ impl Parse<'_> for Stmt {
Ok(_) => Semi::Terminated, Ok(_) => Semi::Terminated,
_ => Semi::Unterminated, _ => Semi::Unterminated,
}, },
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}) })
} }
} }
@ -984,7 +984,7 @@ impl Parse<'_> for AddrOf {
mutable: Mutability::parse(p)?, mutable: Mutability::parse(p)?,
expr: Expr::parse(p)?.into(), expr: Expr::parse(p)?.into(),
}), }),
extents: Span(start, p.loc()), span: Span(start, p.loc()),
} }
.into(), .into(),
}) })

18
compiler/cl-parser/src/parser/prec.rs
View File

@ -41,7 +41,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
Unary { kind, tail: expr(p, after)?.into() }.into() Unary { kind, tail: expr(p, after)?.into() }.into()
} }
}, },
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}; };
fn from_postfix(op: TokenKind) -> Option<Precedence> { fn from_postfix(op: TokenKind) -> Option<Precedence> {
@ -80,10 +80,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
kind: BinaryKind::Call, kind: BinaryKind::Call,
parts: ( parts: (
head, head,
Expr { Expr { kind: Tuple { exprs }.into(), span: Span(start, p.loc()) },
kind: Tuple { exprs }.into(),
extents: Span(start, p.loc()),
},
) )
.into(), .into(),
} }
@ -105,7 +102,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
} }
_ => Err(p.error(Unexpected(op), parsing))?, _ => Err(p.error(Unexpected(op), parsing))?,
}, },
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}; };
continue; continue;
} }
@ -120,7 +117,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
let tail = expr(p, after)?; let tail = expr(p, after)?;
head = Expr { head = Expr {
kind: Binary { kind, parts: (head, tail).into() }.into(), kind: Binary { kind, parts: (head, tail).into() }.into(),
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}; };
continue; continue;
} }
@ -135,7 +132,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
let tail = expr(p, after)?; let tail = expr(p, after)?;
head = Expr { head = Expr {
kind: Modify { kind, parts: (head, tail).into() }.into(), kind: Modify { kind, parts: (head, tail).into() }.into(),
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}; };
continue; continue;
} }
@ -152,7 +149,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
let tail = expr(p, after)?; let tail = expr(p, after)?;
head = Expr { head = Expr {
kind: Assign { parts: (head, tail).into() }.into(), kind: Assign { parts: (head, tail).into() }.into(),
extents: Span(start, p.loc()), span: Span(start, p.loc()),
}; };
continue; continue;
@ -166,8 +163,7 @@ pub fn expr(p: &mut Parser, power: u8) -> PResult<Expr> {
p.consume_peeked(); p.consume_peeked();
let ty = Ty::parse(p)?; let ty = Ty::parse(p)?;
head = head = Expr { kind: Cast { head: head.into(), ty }.into(), span: Span(start, p.loc()) };
Expr { kind: Cast { head: head.into(), ty }.into(), extents: Span(start, p.loc()) };
continue; continue;
} }

16
compiler/cl-repl/examples/yaml.rs
View File

@ -193,7 +193,7 @@ pub mod yamlify {
impl Yamlify for Item { impl Yamlify for Item {
fn yaml(&self, y: &mut Yamler) { fn yaml(&self, y: &mut Yamler) {
let Self { extents: _, attrs, vis, kind } = self; let Self { span: _, attrs, vis, kind } = self;
y.key("Item").yaml(attrs).yaml(vis).yaml(kind); y.key("Item").yaml(attrs).yaml(vis).yaml(kind);
} }
} }
@ -214,8 +214,8 @@ pub mod yamlify {
} }
impl Yamlify for Alias { impl Yamlify for Alias {
fn yaml(&self, y: &mut Yamler) { fn yaml(&self, y: &mut Yamler) {
let Self { to, from } = self; let Self { name, from } = self;
y.key("Alias").pair("to", to).pair("from", from); y.key("Alias").pair("to", name).pair("from", from);
} }
} }
impl Yamlify for Const { impl Yamlify for Const {
@ -235,8 +235,8 @@ pub mod yamlify {
} }
impl Yamlify for Module { impl Yamlify for Module {
fn yaml(&self, y: &mut Yamler) { fn yaml(&self, y: &mut Yamler) {
let Self { name, kind } = self; let Self { name, file } = self;
y.key("Module").pair("name", name).yaml(kind); y.key("Module").pair("name", name).yaml(file);
} }
} }
impl Yamlify for Function { impl Yamlify for Function {
@ -333,7 +333,7 @@ pub mod yamlify {
} }
impl Yamlify for Stmt { impl Yamlify for Stmt {
fn yaml(&self, y: &mut Yamler) { fn yaml(&self, y: &mut Yamler) {
let Self { extents: _, kind, semi } = self; let Self { span: _, kind, semi } = self;
y.key("Stmt").yaml(kind).yaml(semi); y.key("Stmt").yaml(kind).yaml(semi);
} }
} }
@ -355,7 +355,7 @@ pub mod yamlify {
} }
impl Yamlify for Expr { impl Yamlify for Expr {
fn yaml(&self, y: &mut Yamler) { fn yaml(&self, y: &mut Yamler) {
let Self { extents: _, kind } = self; let Self { span: _, kind } = self;
y.yaml(kind); y.yaml(kind);
} }
} }
@ -628,7 +628,7 @@ pub mod yamlify {
} }
impl Yamlify for Ty { impl Yamlify for Ty {
fn yaml(&self, y: &mut Yamler) { fn yaml(&self, y: &mut Yamler) {
let Self { extents: _, kind } = self; let Self { span: _, kind } = self;
y.key("Ty").yaml(kind); y.key("Ty").yaml(kind);
} }
} }

2
compiler/cl-typeck/src/source.rs
View File

@ -25,7 +25,7 @@ impl Source<'_> {
match self { match self {
Source::Root => None, Source::Root => None,
Source::Module(v) => Some(v.name), Source::Module(v) => Some(v.name),
Source::Alias(v) => Some(v.to), Source::Alias(v) => Some(v.name),
Source::Enum(v) => Some(v.name), Source::Enum(v) => Some(v.name),
Source::Variant(v) => Some(v.name), Source::Variant(v) => Some(v.name),
Source::Struct(v) => Some(v.name), Source::Struct(v) => Some(v.name),

14
compiler/cl-typeck/src/stage/populate.rs
View File

@ -33,7 +33,7 @@ impl<'t, 'a> Populator<'t, 'a> {
impl<'a> Visit<'a> for Populator<'_, 'a> { impl<'a> Visit<'a> for Populator<'_, 'a> {
fn visit_item(&mut self, i: &'a cl_ast::Item) { fn visit_item(&mut self, i: &'a cl_ast::Item) {
let cl_ast::Item { extents, attrs, vis, kind } = i; let cl_ast::Item { span, attrs, vis, kind } = i;
// TODO: this, better, better. // TODO: this, better, better.
let entry_kind = match kind { let entry_kind = match kind {
ItemKind::Alias(_) => NodeKind::Type, ItemKind::Alias(_) => NodeKind::Type,
@ -50,10 +50,10 @@ impl<'a> Visit<'a> for Populator<'_, 'a> {
}; };
let mut entry = self.new_entry(entry_kind); let mut entry = self.new_entry(entry_kind);
entry.inner.set_span(*extents); entry.inner.set_span(*span);
entry.inner.set_meta(&attrs.meta); entry.inner.set_meta(&attrs.meta);
entry.visit_span(extents); entry.visit_span(span);
entry.visit_attrs(attrs); entry.visit_attrs(attrs);
entry.visit_visibility(vis); entry.visit_visibility(vis);
entry.visit_item_kind(kind); entry.visit_item_kind(kind);
@ -64,9 +64,9 @@ impl<'a> Visit<'a> for Populator<'_, 'a> {
} }
fn visit_alias(&mut self, a: &'a cl_ast::Alias) { fn visit_alias(&mut self, a: &'a cl_ast::Alias) {
let cl_ast::Alias { to, from } = a; let cl_ast::Alias { name, from } = a;
self.inner.set_source(Source::Alias(a)); self.inner.set_source(Source::Alias(a));
self.set_name(*to); self.set_name(*name);
if let Some(t) = from { if let Some(t) = from {
self.visit_ty(t) self.visit_ty(t)
@ -93,11 +93,11 @@ impl<'a> Visit<'a> for Populator<'_, 'a> {
} }
fn visit_module(&mut self, m: &'a cl_ast::Module) { fn visit_module(&mut self, m: &'a cl_ast::Module) {
let cl_ast::Module { name, kind } = m; let cl_ast::Module { name, file } = m;
self.inner.set_source(Source::Module(m)); self.inner.set_source(Source::Module(m));
self.set_name(*name); self.set_name(*name);
if let Some(file) = kind { if let Some(file) = file {
self.visit_file(file); self.visit_file(file);
} }
} }