From e3d94d8949c13d642cdbdc1bd25722779c17b4f7 Mon Sep 17 00:00:00 2001 From: John Date: Sat, 22 Feb 2025 05:16:37 -0600 Subject: [PATCH] conlang: Unify binding operations! This breaks out the pattern matching/unification algorithm from cl-interpret/interpret.rs to cl-interpret/pattern.rs TODO: pattern destructuring in const, static :^) --- compiler/cl-ast/src/ast.rs | 2 +- compiler/cl-ast/src/ast_impl.rs | 12 +- compiler/cl-ast/src/ast_visitor/fold.rs | 4 +- compiler/cl-ast/src/ast_visitor/visit.rs | 4 +- compiler/cl-interpret/src/convalue.rs | 2 +- compiler/cl-interpret/src/function.rs | 8 +- .../src/function/collect_upvars.rs | 4 +- compiler/cl-interpret/src/interpret.rs | 149 ++---------------- compiler/cl-interpret/src/lib.rs | 2 + compiler/cl-interpret/src/pattern.rs | 130 +++++++++++++++ compiler/cl-parser/src/error.rs | 3 + compiler/cl-parser/src/parser.rs | 20 ++- compiler/cl-parser/src/parser/prec.rs | 29 +++- compiler/cl-repl/examples/yaml.rs | 4 +- 14 files changed, 202 insertions(+), 171 deletions(-) create mode 100644 compiler/cl-interpret/src/pattern.rs diff --git a/compiler/cl-ast/src/ast.rs b/compiler/cl-ast/src/ast.rs index 1f073b6..02c8e18 100644 --- a/compiler/cl-ast/src/ast.rs +++ b/compiler/cl-ast/src/ast.rs @@ -153,7 +153,7 @@ pub struct Function { #[derive(Clone, Debug, PartialEq, Eq, Hash)] pub struct Param { pub mutability: Mutability, - pub name: Sym, + pub bind: Pattern, } /// A user-defined product type diff --git a/compiler/cl-ast/src/ast_impl.rs b/compiler/cl-ast/src/ast_impl.rs index 80b02ab..decf56e 100644 --- a/compiler/cl-ast/src/ast_impl.rs +++ b/compiler/cl-ast/src/ast_impl.rs @@ -194,8 +194,8 @@ mod display { impl Display for Param { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - let Self { mutability, name } = self; - write!(f, "{mutability}{name}") + let Self { mutability, bind } = self; + write!(f, "{mutability}{bind}") } } @@ -474,11 +474,11 @@ mod display { Pattern::Tuple(patterns) => separate(patterns, ", ")(f.delimit(INLINE_PARENS)), Pattern::Array(patterns) => separate(patterns, ", ")(f.delimit(INLINE_SQUARE)), Pattern::Struct(path, items) => { - write!(f, "{path}: ")?; - let f = &mut f.delimit(BRACES); + write!(f, "{path} ")?; + let f = &mut f.delimit(INLINE_BRACES); for (idx, (name, item)) in items.iter().enumerate() { if idx != 0 { - f.write_str(",\n")?; + f.write_str(", ")?; } write!(f, "{name}")?; if let Some(pattern) = item { @@ -639,7 +639,7 @@ mod display { impl Display for Structor { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let Self { to, init } = self; - write!(f, "{to}: ")?; + write!(f, "{to} ")?; separate(init, ", ")(f.delimit(INLINE_BRACES)) } } diff --git a/compiler/cl-ast/src/ast_visitor/fold.rs b/compiler/cl-ast/src/ast_visitor/fold.rs index 52e8b07..753ee65 100644 --- a/compiler/cl-ast/src/ast_visitor/fold.rs +++ b/compiler/cl-ast/src/ast_visitor/fold.rs @@ -111,8 +111,8 @@ pub trait Fold { } } fn fold_param(&mut self, p: Param) -> Param { - let Param { mutability, name } = p; - Param { mutability: self.fold_mutability(mutability), name: self.fold_sym(name) } + let Param { mutability, bind } = p; + Param { mutability: self.fold_mutability(mutability), bind: self.fold_pattern(bind) } } fn fold_struct(&mut self, s: Struct) -> Struct { let Struct { name, kind } = s; diff --git a/compiler/cl-ast/src/ast_visitor/visit.rs b/compiler/cl-ast/src/ast_visitor/visit.rs index 420a5fb..522e5ca 100644 --- a/compiler/cl-ast/src/ast_visitor/visit.rs +++ b/compiler/cl-ast/src/ast_visitor/visit.rs @@ -89,9 +89,9 @@ pub trait Visit<'a>: Sized { } } fn visit_param(&mut self, p: &'a Param) { - let Param { mutability, name } = p; + let Param { mutability, bind } = p; self.visit_mutability(mutability); - self.visit_sym(name); + self.visit_pattern(bind); } fn visit_struct(&mut self, s: &'a Struct) { let Struct { name, kind } = s; diff --git a/compiler/cl-interpret/src/convalue.rs b/compiler/cl-interpret/src/convalue.rs index a97b6df..2f6db3f 100644 --- a/compiler/cl-interpret/src/convalue.rs +++ b/compiler/cl-interpret/src/convalue.rs @@ -319,7 +319,7 @@ impl std::fmt::Display for ConValue { let (name, map) = parts.as_ref(); use std::fmt::Write; if !name.is_empty() { - write!(f, "{name}: ")?; + write!(f, "{name} ")?; } let mut f = f.delimit_with("{", "\n}"); for (k, v) in map.iter() { diff --git a/compiler/cl-interpret/src/function.rs b/compiler/cl-interpret/src/function.rs index a9e1bb5..a4281a2 100644 --- a/compiler/cl-interpret/src/function.rs +++ b/compiler/cl-interpret/src/function.rs @@ -2,7 +2,7 @@ use collect_upvars::collect_upvars; -use super::{Callable, ConValue, Environment, Error, IResult, Interpret}; +use super::{pattern, Callable, ConValue, Environment, Error, IResult, Interpret}; use cl_ast::{Function as FnDecl, Param, Sym}; use std::{ cell::{Ref, RefCell}, @@ -70,8 +70,10 @@ impl Callable for Function { // TODO: completely refactor data storage let mut frame = env.frame("fn args"); - for (Param { mutability: _, name }, value) in bind.iter().zip(args) { - frame.insert(*name, Some(value.clone())); + for (Param { mutability: _, bind }, value) in bind.iter().zip(args) { + for (name, value) in pattern::substitution(bind, value.clone())? { + frame.insert(*name, Some(value)); + } } let res = body.interpret(&mut frame); drop(frame); diff --git a/compiler/cl-interpret/src/function/collect_upvars.rs b/compiler/cl-interpret/src/function/collect_upvars.rs index ce87361..84555e5 100644 --- a/compiler/cl-interpret/src/function/collect_upvars.rs +++ b/compiler/cl-interpret/src/function/collect_upvars.rs @@ -67,8 +67,8 @@ impl<'a> Visit<'a> for CollectUpvars<'_> { fn visit_function(&mut self, f: &'a cl_ast::Function) { let Function { name: _, sign: _, bind, body } = f; // parameters can never be upvars - for Param { mutability: _, name } in bind { - self.bind_name(name); + for Param { mutability: _, bind } in bind { + self.visit_pattern(bind); } if let Some(body) = body { self.visit_expr(body); diff --git a/compiler/cl-interpret/src/interpret.rs b/compiler/cl-interpret/src/interpret.rs index fc35c6b..dc1dd40 100644 --- a/compiler/cl-interpret/src/interpret.rs +++ b/compiler/cl-interpret/src/interpret.rs @@ -139,7 +139,7 @@ impl Interpret for Struct { .enumerate() .map(|(idx, _)| Param { mutability: Mutability::Not, - name: idx.to_string().into(), + bind: Pattern::Name(idx.to_string().into()), }) .collect(), body: None, @@ -300,12 +300,12 @@ impl Interpret for Let { let Let { mutable: _, name, ty: _, init } = self; match init.as_ref().map(|i| i.interpret(env)).transpose()? { Some(value) => { - for (name, value) in assignment::pattern_substitution(name, value)? { + for (name, value) in pattern::substitution(name, value)? { env.insert(*name, Some(value)); } } None => { - for name in assignment::pattern_variables(name) { + for name in pattern::variables(name) { env.insert(*name, None); } } @@ -319,7 +319,7 @@ impl Interpret for Match { let Self { scrutinee, arms } = self; let scrutinee = scrutinee.interpret(env)?; for MatchArm(pat, expr) in arms { - if let Ok(substitution) = assignment::pattern_substitution(pat, scrutinee.clone()) { + if let Ok(substitution) = pattern::substitution(pat, scrutinee.clone()) { let mut env = env.frame("match"); for (name, value) in substitution { env.insert(*name, Some(value)); @@ -337,136 +337,11 @@ mod assignment { use std::collections::HashMap; type Namespace = HashMap>; - /// Gets the path variables in the given Pattern - pub fn pattern_variables(pat: &Pattern) -> Vec<&Sym> { - fn patvars<'p>(set: &mut Vec<&'p Sym>, pat: &'p Pattern) { - match pat { - Pattern::Name(name) if &**name == "_" => {} - Pattern::Name(name) => set.push(name), - Pattern::Literal(_) => {} - Pattern::Ref(_, pattern) => patvars(set, pattern), - Pattern::Tuple(patterns) | Pattern::Array(patterns) => { - patterns.iter().for_each(|pat| patvars(set, pat)) - } - Pattern::Struct(_path, items) => { - items.iter().for_each(|(name, pat)| match pat { - Some(pat) => patvars(set, pat), - None => set.push(name), - }); - } - Pattern::TupleStruct(_path, items) => { - items.iter().for_each(|pat| patvars(set, pat)); - } - } - } - let mut set = Vec::new(); - patvars(&mut set, pat); - set - } - - /// Appends a substitution to the provided table - pub fn append_sub<'pat>( - sub: &mut HashMap<&'pat Sym, ConValue>, - pat: &'pat Pattern, - value: ConValue, - ) -> IResult<()> { - match (pat, value) { - (Pattern::Array(patterns), ConValue::Array(values)) - | (Pattern::Tuple(patterns), ConValue::Tuple(values)) => { - if patterns.len() != values.len() { - Err(Error::ArgNumber { want: patterns.len(), got: values.len() })? - } - for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) { - append_sub(sub, pat, value)?; - } - Ok(()) - } - (Pattern::Tuple(patterns), ConValue::Empty) if patterns.is_empty() => Ok(()), - - (Pattern::Literal(Literal::Bool(a)), ConValue::Bool(b)) => { - (*a == b).then_some(()).ok_or(Error::NotAssignable) - } - (Pattern::Literal(Literal::Char(a)), ConValue::Char(b)) => { - (*a == b).then_some(()).ok_or(Error::NotAssignable) - } - (Pattern::Literal(Literal::Float(a)), ConValue::Float(b)) => (f64::from_bits(*a) == b) - .then_some(()) - .ok_or(Error::NotAssignable), - (Pattern::Literal(Literal::Int(a)), ConValue::Int(b)) => { - (b == *a as _).then_some(()).ok_or(Error::NotAssignable) - } - (Pattern::Literal(Literal::String(a)), ConValue::String(b)) => { - (*a == *b).then_some(()).ok_or(Error::NotAssignable) - } - (Pattern::Literal(_), _) => Err(Error::NotAssignable), - - (Pattern::Name(name), _) if "_".eq(&**name) => Ok(()), - (Pattern::Name(name), value) => { - sub.insert(name, value); - Ok(()) - } - - (Pattern::Ref(_, pat), ConValue::Ref(r)) => { - append_sub(sub, pat, Rc::unwrap_or_clone(r)) - } - - (Pattern::Struct(path, patterns), ConValue::Struct(parts)) => { - let (name, mut values) = *parts; - if !path.ends_with(&name) { - Err(Error::TypeError)? - } - if patterns.len() != values.len() { - return Err(Error::ArgNumber { want: patterns.len(), got: values.len() }); - } - for (name, pat) in patterns { - let value = values.remove(name).ok_or(Error::TypeError)?; - match pat { - Some(pat) => append_sub(sub, pat, value)?, - None => { - sub.insert(name, value); - } - } - } - Ok(()) - } - - (Pattern::TupleStruct(path, patterns), ConValue::TupleStruct(parts)) => { - let (name, values) = *parts; - if !path.ends_with(&name) { - Err(Error::TypeError)? - } - if patterns.len() != values.len() { - Err(Error::ArgNumber { want: patterns.len(), got: values.len() })? - } - for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) { - append_sub(sub, pat, value)?; - } - Ok(()) - } - - (pat, value) => { - eprintln!("Could not match pattern `{pat}` with value `{value}`!"); - Err(Error::NotAssignable) - } - } - } - - /// Constructs a substitution from a pattern and a value - pub fn pattern_substitution( - pat: &Pattern, - value: ConValue, - ) -> IResult> { - let mut sub = HashMap::new(); - append_sub(&mut sub, pat, value)?; - Ok(sub) - } - pub(super) fn pat_assign(env: &mut Environment, pat: &Pattern, value: ConValue) -> IResult<()> { - let mut substitution = HashMap::new(); - append_sub(&mut substitution, pat, value) - .map_err(|_| Error::PatFailed(pat.clone().into()))?; - for (path, value) in substitution { - env.insert(*path, Some(value)); + for (name, value) in + pattern::substitution(pat, value).map_err(|_| Error::PatFailed(pat.clone().into()))? + { + *env.get_mut(*name)? = Some(value); } Ok(()) } @@ -478,6 +353,7 @@ mod assignment { match pat { ExprKind::Member(member) => *addrof_member(env, member)? = value, ExprKind::Index(index) => *addrof_index(env, index)? = value, + ExprKind::Path(path) => *addrof_path(env, &path.parts)? = Some(value), _ => Err(Error::NotAssignable)?, } Ok(()) @@ -978,7 +854,7 @@ impl Interpret for If { } impl Interpret for For { fn interpret(&self, env: &mut Environment) -> IResult { - let Self { bind: name, cond, pass, fail } = self; + let Self { bind, cond, pass, fail } = self; let cond = cond.interpret(env)?; // TODO: A better iterator model let mut bounds: Box> = match &cond { @@ -990,9 +866,8 @@ impl Interpret for For { }; loop { let mut env = env.frame("loop variable"); - if let Some(loop_var) = bounds.next() { - let subs = assignment::pattern_substitution(name, loop_var)?; - for (name, value) in subs { + if let Some(value) = bounds.next() { + for (name, value) in pattern::substitution(bind, value)? { env.insert(*name, Some(value)); } match pass.interpret(&mut env) { diff --git a/compiler/cl-interpret/src/lib.rs b/compiler/cl-interpret/src/lib.rs index 0a88f9d..b0ef7ca 100644 --- a/compiler/cl-interpret/src/lib.rs +++ b/compiler/cl-interpret/src/lib.rs @@ -25,6 +25,8 @@ pub mod function; pub mod builtin; +pub mod pattern; + pub mod env; pub mod error; diff --git a/compiler/cl-interpret/src/pattern.rs b/compiler/cl-interpret/src/pattern.rs new file mode 100644 index 0000000..eb6d678 --- /dev/null +++ b/compiler/cl-interpret/src/pattern.rs @@ -0,0 +1,130 @@ +//! Unification algorithm for cl-ast patterns and ConValues +//! +//! [`variables()`] returns a flat list of symbols that are bound by a given pattern +//! [`substitution()`] unifies a ConValue with a pattern, and produces a list of bound names + +use crate::{ + convalue::ConValue, + error::{Error, IResult}, +}; +use cl_ast::{Literal, Pattern, Sym}; +use std::{collections::HashMap, rc::Rc}; + +/// Gets the path variables in the given Pattern +pub fn variables(pat: &Pattern) -> Vec<&Sym> { + fn patvars<'p>(set: &mut Vec<&'p Sym>, pat: &'p Pattern) { + match pat { + Pattern::Name(name) if &**name == "_" => {} + Pattern::Name(name) => set.push(name), + Pattern::Literal(_) => {} + Pattern::Ref(_, pattern) => patvars(set, pattern), + Pattern::Tuple(patterns) | Pattern::Array(patterns) => { + patterns.iter().for_each(|pat| patvars(set, pat)) + } + Pattern::Struct(_path, items) => { + items.iter().for_each(|(name, pat)| match pat { + Some(pat) => patvars(set, pat), + None => set.push(name), + }); + } + Pattern::TupleStruct(_path, items) => { + items.iter().for_each(|pat| patvars(set, pat)); + } + } + } + let mut set = Vec::new(); + patvars(&mut set, pat); + set +} + +/// Appends a substitution to the provided table +pub fn append_sub<'pat>( + sub: &mut HashMap<&'pat Sym, ConValue>, + pat: &'pat Pattern, + value: ConValue, +) -> IResult<()> { + match (pat, value) { + (Pattern::Array(patterns), ConValue::Array(values)) + | (Pattern::Tuple(patterns), ConValue::Tuple(values)) => { + if patterns.len() != values.len() { + Err(Error::ArgNumber { want: patterns.len(), got: values.len() })? + } + for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) { + append_sub(sub, pat, value)?; + } + Ok(()) + } + (Pattern::Tuple(patterns), ConValue::Empty) if patterns.is_empty() => Ok(()), + + (Pattern::Literal(Literal::Bool(a)), ConValue::Bool(b)) => { + (*a == b).then_some(()).ok_or(Error::NotAssignable) + } + (Pattern::Literal(Literal::Char(a)), ConValue::Char(b)) => { + (*a == b).then_some(()).ok_or(Error::NotAssignable) + } + (Pattern::Literal(Literal::Float(a)), ConValue::Float(b)) => (f64::from_bits(*a) == b) + .then_some(()) + .ok_or(Error::NotAssignable), + (Pattern::Literal(Literal::Int(a)), ConValue::Int(b)) => { + (b == *a as _).then_some(()).ok_or(Error::NotAssignable) + } + (Pattern::Literal(Literal::String(a)), ConValue::String(b)) => { + (*a == *b).then_some(()).ok_or(Error::NotAssignable) + } + (Pattern::Literal(_), _) => Err(Error::NotAssignable), + + (Pattern::Name(name), _) if "_".eq(&**name) => Ok(()), + (Pattern::Name(name), value) => { + sub.insert(name, value); + Ok(()) + } + + (Pattern::Ref(_, pat), ConValue::Ref(r)) => append_sub(sub, pat, Rc::unwrap_or_clone(r)), + + (Pattern::Struct(path, patterns), ConValue::Struct(parts)) => { + let (name, mut values) = *parts; + if !path.ends_with(&name) { + Err(Error::TypeError)? + } + if patterns.len() != values.len() { + return Err(Error::ArgNumber { want: patterns.len(), got: values.len() }); + } + for (name, pat) in patterns { + let value = values.remove(name).ok_or(Error::TypeError)?; + match pat { + Some(pat) => append_sub(sub, pat, value)?, + None => { + sub.insert(name, value); + } + } + } + Ok(()) + } + + (Pattern::TupleStruct(path, patterns), ConValue::TupleStruct(parts)) => { + let (name, values) = *parts; + if !path.ends_with(&name) { + Err(Error::TypeError)? + } + if patterns.len() != values.len() { + Err(Error::ArgNumber { want: patterns.len(), got: values.len() })? + } + for (pat, value) in patterns.iter().zip(Vec::from(values).into_iter()) { + append_sub(sub, pat, value)?; + } + Ok(()) + } + + (pat, value) => { + eprintln!("Could not match pattern `{pat}` with value `{value}`!"); + Err(Error::NotAssignable) + } + } +} + +/// Constructs a substitution from a pattern and a value +pub fn substitution(pat: &Pattern, value: ConValue) -> IResult> { + let mut sub = HashMap::new(); + append_sub(&mut sub, pat, value)?; + Ok(sub) +} diff --git a/compiler/cl-parser/src/error.rs b/compiler/cl-parser/src/error.rs index bb714dc..b454325 100644 --- a/compiler/cl-parser/src/error.rs +++ b/compiler/cl-parser/src/error.rs @@ -1,5 +1,6 @@ use super::*; +use cl_ast::ExprKind; use cl_lexer::error::{Error as LexError, Reason}; use std::fmt::Display; pub type PResult = Result; @@ -29,6 +30,7 @@ pub enum ErrorKind { ExpectedParsing { want: Parsing, }, + InvalidPattern(Box), /// Indicates unfinished code Todo(&'static str), } @@ -148,6 +150,7 @@ impl Display for ErrorKind { ErrorKind::Unexpected(t) => write!(f, "Encountered unexpected token `{t}`"), ErrorKind::ExpectedToken { want: e, got: g } => write!(f, "Expected `{e}`, got `{g}`"), ErrorKind::ExpectedParsing { want } => write!(f, "Expected {want}"), + ErrorKind::InvalidPattern(got) => write!(f, "Got invalid `{got}`"), ErrorKind::Todo(unfinished) => write!(f, "TODO: {unfinished}"), } } diff --git a/compiler/cl-parser/src/parser.rs b/compiler/cl-parser/src/parser.rs index e1aa1f7..4c80265 100644 --- a/compiler/cl-parser/src/parser.rs +++ b/compiler/cl-parser/src/parser.rs @@ -494,7 +494,7 @@ impl Parse<'_> for TypedParam { /// Parses a single function [parameter](Param) fn parse(p: &mut Parser) -> PResult<(Param, TyKind)> { Ok(( - Param { mutability: Mutability::parse(p)?, name: Sym::parse(p)? }, + Param { mutability: Mutability::parse(p)?, bind: Pattern::parse(p)? }, { p.match_type(TokenKind::Colon, Parsing::Param)?; TyKind::parse(p)? @@ -1006,13 +1006,20 @@ impl Parse<'_> for Block { } } +/// Conditions (which precede curly-braced blocks) get special treatment +fn condition(p: &mut Parser) -> PResult { + let start = p.loc(); + let kind = prec::exprkind(p, prec::Precedence::Condition.level())?; + Ok(Expr { kind, extents: Span(start, p.loc()) }) +} + impl Parse<'_> for While { /// [While] = `while` [Expr] [Block] [Else]? #[rustfmt::skip] fn parse(p: &mut Parser) -> PResult { p.match_type(TokenKind::While, Parsing::While)?; Ok(While { - cond: Expr::parse(p)?.into(), + cond: condition(p)?.into(), pass: Block::parse(p)?.into(), fail: Else::parse(p)? }) @@ -1025,7 +1032,7 @@ impl Parse<'_> for If { fn parse(p: &mut Parser) -> PResult { p.match_type(TokenKind::If, Parsing::If)?; Ok(If { - cond: Expr::parse(p)?.into(), + cond: condition(p)?.into(), pass: Block::parse(p)?.into(), fail: Else::parse(p)?, }) @@ -1033,7 +1040,7 @@ impl Parse<'_> for If { } impl Parse<'_> for For { - /// [For]: `for` Pattern (TODO) `in` [Expr] [Block] [Else]? + /// [For]: `for` [Pattern] `in` [Expr] [Block] [Else]? #[rustfmt::skip] fn parse(p: &mut Parser) -> PResult { p.match_type(TokenKind::For, Parsing::For)?; @@ -1041,7 +1048,7 @@ impl Parse<'_> for For { p.match_type(TokenKind::In, Parsing::For)?; Ok(For { bind, - cond: Expr::parse(p)?.into(), + cond: condition(p)?.into(), pass: Block::parse(p)?.into(), fail: Else::parse(p)?, }) @@ -1081,8 +1088,7 @@ impl Parse<'_> for Return { impl Parse<'_> for Pattern { fn parse(p: &mut Parser<'_>) -> PResult { let value = prec::exprkind(p, prec::Precedence::Pattern.level())?; - Pattern::try_from(value) - .map_err(|_| p.error(ExpectedParsing { want: Parsing::Pattern }, Parsing::Pattern)) + Pattern::try_from(value).map_err(|e| p.error(InvalidPattern(e.into()), Parsing::Pattern)) } } diff --git a/compiler/cl-parser/src/parser/prec.rs b/compiler/cl-parser/src/parser/prec.rs index a13584e..88cffc2 100644 --- a/compiler/cl-parser/src/parser/prec.rs +++ b/compiler/cl-parser/src/parser/prec.rs @@ -44,7 +44,9 @@ pub fn exprkind(p: &mut Parser, power: u8) -> PResult { Some(match op { TokenKind::LBrack => Precedence::Index, TokenKind::LParen => Precedence::Call, + TokenKind::LCurly => Precedence::Structor, TokenKind::Dot => Precedence::Member, + TokenKind::As => Precedence::Cast, _ => None?, }) } @@ -55,25 +57,36 @@ pub fn exprkind(p: &mut Parser, power: u8) -> PResult { if before < power { break; } - p.consume_peeked(); head = match op { TokenKind::LBrack => { + p.consume_peeked(); let indices = sep(Expr::parse, TokenKind::Comma, TokenKind::RBrack, parsing)(p)?; p.match_type(TokenKind::RBrack, parsing)?; ExprKind::Index(Index { head: head.into(), indices }) } TokenKind::LParen => { + p.consume_peeked(); let exprs = sep(Expr::parse, TokenKind::Comma, TokenKind::RParen, parsing)(p)?; p.match_type(TokenKind::RParen, parsing)?; Binary { kind: BinaryKind::Call, parts: (head, Tuple { exprs }.into()).into() } .into() } + TokenKind::LCurly => match head { + ExprKind::Path(path) => ExprKind::Structor(structor_body(p, path)?), + _ => break, + }, TokenKind::Dot => { + p.consume_peeked(); let kind = MemberKind::parse(p)?; Member { head: Box::new(head), kind }.into() } + TokenKind::As => { + p.consume_peeked(); + let ty = Ty::parse(p)?; + Cast { head: head.into(), ty }.into() + } _ => Err(p.error(Unexpected(op), parsing))?, }; continue; @@ -217,11 +230,7 @@ fn exprkind_group(p: &mut Parser) -> PResult { /// Parses an expression beginning with a [Path] (i.e. [Path] or [Structor]) fn exprkind_pathlike(p: &mut Parser) -> PResult { - let head = Path::parse(p)?; - Ok(match p.match_type(TokenKind::Colon, Parsing::Path) { - Ok(_) => ExprKind::Structor(structor_body(p, head)?), - Err(_) => ExprKind::Path(head), - }) + Path::parse(p).map(Into::into) } /// [Structor]Body = `{` ([Fielder] `,`)* [Fielder]? `}` @@ -244,6 +253,9 @@ fn structor_body(p: &mut Parser, to: Path) -> PResult { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum Precedence { Assign, + Pattern, // A pattern can contain a structor + Structor, // A structor is never a valid conditional + Condition, // Anything that syntactically needs a block following it Logic, Compare, Range, @@ -255,7 +267,6 @@ pub enum Precedence { Index, Cast, Member, // left-associative - Pattern, Call, } @@ -284,7 +295,9 @@ impl Precedence { pub fn postfix(self) -> Option<(u8, ())> { match self { - Self::Index | Self::Call | Self::Member => Some((self.level(), ())), + Self::Structor | Self::Index | Self::Call | Self::Member | Self::Cast => { + Some((self.level(), ())) + } _ => None, } } diff --git a/compiler/cl-repl/examples/yaml.rs b/compiler/cl-repl/examples/yaml.rs index 887b83f..58246b6 100644 --- a/compiler/cl-repl/examples/yaml.rs +++ b/compiler/cl-repl/examples/yaml.rs @@ -643,8 +643,8 @@ pub mod yamlify { } impl Yamlify for Param { fn yaml(&self, y: &mut Yamler) { - let Self { mutability, name } = self; - y.key("Param").yaml(mutability).pair("name", name); + let Self { mutability, bind } = self; + y.key("Param").yaml(mutability).pair("pat", bind); } } impl Yamlify for Ty {