update chumsky to `main` · hjvt.dev/rotth@9ab1a6b

+70 -2

Cargo.lock

··· 227 227 [[package]] 228 228 name = "chumsky" 229 229 version = "1.0.0-alpha.6" 230 - source = "registry+https://github.com/rust-lang/crates.io-index" 231 - checksum = "b9c28d4e5dd9a9262a38b231153591da6ce1471b818233f4727985d3dd0ed93c" 230 + source = "git+https://github.com/zesterer/chumsky.git?rev=d0ec108d8fb4233f7eb41d625409bd6804b9fbed#d0ec108d8fb4233f7eb41d625409bd6804b9fbed" 232 231 dependencies = [ 233 232 "hashbrown 0.14.3", 234 233 "regex-automata 0.3.9", ··· 784 783 ] 785 784 786 785 [[package]] 786 + name = "nu-ansi-term" 787 + version = "0.46.0" 788 + source = "registry+https://github.com/rust-lang/crates.io-index" 789 + checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" 790 + dependencies = [ 791 + "overload", 792 + "winapi", 793 + ] 794 + 795 + [[package]] 787 796 name = "num_cpus" 788 797 version = "1.16.0" 789 798 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 810 819 version = "1.19.0" 811 820 source = "registry+https://github.com/rust-lang/crates.io-index" 812 821 checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" 822 + 823 + [[package]] 824 + name = "overload" 825 + version = "0.1.1" 826 + source = "registry+https://github.com/rust-lang/crates.io-index" 827 + checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" 813 828 814 829 [[package]] 815 830 name = "parking_lot" ··· 1136 1151 ] 1137 1152 1138 1153 [[package]] 1154 + name = "sharded-slab" 1155 + version = "0.1.7" 1156 + source = "registry+https://github.com/rust-lang/crates.io-index" 1157 + checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" 1158 + dependencies = [ 1159 + "lazy_static", 1160 + ] 1161 + 1162 + [[package]] 1139 1163 name = "signal-hook-registry" 1140 1164 version = "1.4.1" 1141 1165 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1172 1196 "somok", 1173 1197 "spanner", 1174 1198 "thiserror", 1199 + "tracing", 1200 + "tracing-subscriber", 1175 1201 ] 1176 1202 1177 1203 [[package]] ··· 1298 1324 ] 1299 1325 1300 1326 [[package]] 1327 + name = "thread_local" 1328 + version = "1.1.8" 1329 + source = "registry+https://github.com/rust-lang/crates.io-index" 1330 + checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" 1331 + dependencies = [ 1332 + "cfg-if", 1333 + "once_cell", 1334 + ] 1335 + 1336 + [[package]] 1301 1337 name = "tinyvec" 1302 1338 version = "1.6.0" 1303 1339 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1445 1481 checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" 1446 1482 dependencies = [ 1447 1483 "once_cell", 1484 + "valuable", 1485 + ] 1486 + 1487 + [[package]] 1488 + name = "tracing-log" 1489 + version = "0.2.0" 1490 + source = "registry+https://github.com/rust-lang/crates.io-index" 1491 + checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" 1492 + dependencies = [ 1493 + "log", 1494 + "once_cell", 1495 + "tracing-core", 1496 + ] 1497 + 1498 + [[package]] 1499 + name = "tracing-subscriber" 1500 + version = "0.3.18" 1501 + source = "registry+https://github.com/rust-lang/crates.io-index" 1502 + checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b" 1503 + dependencies = [ 1504 + "nu-ansi-term", 1505 + "sharded-slab", 1506 + "smallvec", 1507 + "thread_local", 1508 + "tracing-core", 1509 + "tracing-log", 1448 1510 ] 1449 1511 1450 1512 [[package]] ··· 1491 1553 version = "0.2.1" 1492 1554 source = "registry+https://github.com/rust-lang/crates.io-index" 1493 1555 checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" 1556 + 1557 + [[package]] 1558 + name = "valuable" 1559 + version = "0.1.0" 1560 + source = "registry+https://github.com/rust-lang/crates.io-index" 1561 + checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" 1494 1562 1495 1563 [[package]] 1496 1564 name = "version_check"

+6 -1

Cargo.toml

··· 13 13 ] 14 14 15 15 [workspace.dependencies] 16 - chumsky = { version = "1.0.0-alpha.6", features = ["pratt", "label"] } 16 + chumsky = { git = "https://github.com/zesterer/chumsky.git", rev = "d0ec108d8fb4233f7eb41d625409bd6804b9fbed", features = [ 17 + "pratt", 18 + "label", 19 + ] } 17 20 logos = "0.14" 18 21 ariadne = "0.4" 19 22 clap = { version = "4", features = ["derive"] } ··· 25 28 somok = "1.5.0" 26 29 fnv = "1.0.7" 27 30 slotmap = "1.0.7" 31 + tracing = "0.1.40" 32 + tracing-subscriber = "0.3.18"

+6 -3

rotth-parser/src/ast/parsers.rs

··· 1 - use chumsky::{input::ValueInput, prelude::*}; 1 + use chumsky::{ 2 + input::{MapExtra, ValueInput}, 3 + prelude::*, 4 + }; 2 5 use internment::Intern; 3 6 use logos::Logos; 4 7 use rotth_lexer::Token; ··· 37 40 let generic_params = lbracket() 38 41 .then(ty.repeated().at_least(1).collect()) 39 42 .then(rbracket()) 40 - .map_with(|((left_bracket, tys), right_bracket), span| Spanned { 41 - span: span.span(), 43 + .map_with(|((left_bracket, tys), right_bracket), extra| Spanned { 44 + span: extra.span(), 42 45 inner: GenericParams { 43 46 left_bracket, 44 47 tys,

+2

slate-frontend/Cargo.toml

··· 13 13 thiserror.workspace = true 14 14 clap.workspace = true 15 15 slotmap.workspace = true 16 + tracing.workspace = true 17 + tracing-subscriber.workspace = true 16 18 17 19 spanner = { path = "../spanner" } 18 20 itempath = { path = "../itempath" }

+1

slate-frontend/src/lexer.rs

··· 187 187 } 188 188 } 189 189 190 + #[tracing::instrument] 190 191 pub fn lex(src: &str, path: Intern<PathBuf>) -> (Vec<(Token, Span)>, Span) { 191 192 let tt: Vec<_> = Token::lexer(src) 192 193 .spanned()

+8 -2

slate-frontend/src/main.rs

··· 9 9 } 10 10 11 11 fn main() -> std::io::Result<()> { 12 + tracing_subscriber::fmt() 13 + .pretty() 14 + .with_timer(tracing_subscriber::fmt::time::uptime()) 15 + .with_span_events( 16 + tracing_subscriber::fmt::format::FmtSpan::ENTER 17 + | tracing_subscriber::fmt::format::FmtSpan::EXIT, 18 + ) 19 + .init(); 12 20 let args = Args::parse(); 13 21 let src = std::fs::read_to_string(&args.source)?; 14 22 let (tokens, eoi) = slate_frontend::lexer::lex(&src, Intern::new(args.source)); 15 - println!("{tokens:?}"); 16 23 let ast = slate_frontend::parser::parse(tokens, eoi).unwrap(); 17 - dbg!(ast); 18 24 19 25 Ok(()) 20 26 }

+6 -3

slate-frontend/src/parser.rs

··· 14 14 use self::ast::{Module, ModuleDef, ResolvedModule, Word}; 15 15 16 16 pub mod ast; 17 + pub mod flat_ast; 18 + mod flat_parsers; 17 19 mod parsers; 18 20 mod types; 19 21 22 + #[tracing::instrument] 20 23 fn parse_file(tokens: Vec<(Token, Span)>, eoi: Span) -> Result<Module, ParserError<'static>> { 21 24 parsers::file() 22 25 .parse(Stream::from_iter(tokens).spanned(eoi)) ··· 24 27 .map_err(|e| e.into()) 25 28 } 26 29 30 + #[tracing::instrument] 27 31 pub fn parse( 28 32 tokens: Vec<(Token, Span)>, 29 33 eoi: Span, 30 34 ) -> Result<ResolvedModule, ParserError<'static>> { 31 - let root = parsers::file() 32 - .parse(Stream::from_iter(tokens).spanned(eoi)) 33 - .into_result()?; 35 + let root = parse_file(tokens, eoi)?; 34 36 let path = eoi.file.file_stem().unwrap().to_string_lossy(); 35 37 let path = Intern::<String>::from_ref(&*path); 36 38 resolve_modules(root, ItemPathBuf::from(vec![path])) 37 39 } 38 40 41 + #[tracing::instrument] 39 42 pub fn resolve_modules( 40 43 Module { 41 44 funcs,

+1 -19

slate-frontend/src/parser/ast.rs

··· 3 3 use super::types::Type; 4 4 use internment::Intern; 5 5 use itempath::ItemPathBuf; 6 - use slotmap::SlotMap; 7 - use spanner::{Span, Spanned}; 6 + use spanner::Spanned; 8 7 9 8 #[derive(Debug, Clone)] 10 9 pub struct ResolvedModule { ··· 17 16 pub trait_impls: Vec<Spanned<TraitImpl>>, 18 17 pub modules: Vec<Spanned<ResolvedModule>>, 19 18 pub uses: Vec<Spanned<Use>>, 20 - } 21 - 22 - pub mod key { 23 - slotmap::new_key_type! { 24 - pub struct Module; 25 - pub struct Span; 26 - pub struct Func; 27 - pub struct Expr; 28 - } 29 - } 30 - 31 - #[derive(Debug, Default, Clone)] 32 - pub struct Ast { 33 - pub modules: SlotMap<key::Module, Module>, 34 - pub funcs: SlotMap<key::Func, Func>, 35 - pub spans: SlotMap<key::Span, Span>, 36 - pub exprs: SlotMap<key::Expr, Expr>, 37 19 } 38 20 39 21 #[derive(Debug, Clone)]

+461

slate-frontend/src/parser/flat_ast.rs

··· 1 + use internment::Intern; 2 + use itempath::{path, ItemPathBuf}; 3 + use slotmap::SlotMap; 4 + use spanner::{Span, Spanned}; 5 + 6 + pub mod key { 7 + slotmap::new_key_type! { 8 + pub struct Entity; 9 + pub struct Module; 10 + pub struct Func; 11 + pub struct Expr; 12 + } 13 + } 14 + 15 + #[derive(Debug, Default)] 16 + pub struct Ast { 17 + pub modules: SlotMap<key::Module, Spanned<Module>>, 18 + pub funcs: SlotMap<key::Func, Spanned<Func>>, 19 + pub exprs: SlotMap<key::Expr, Spanned<Expr>>, 20 + } 21 + 22 + impl Ast { 23 + pub fn insert<T: AstEntity>(&mut self, ent: T) -> Spanned<T::Key> { 24 + ent.emit(self) 25 + } 26 + } 27 + 28 + pub trait AstEntity { 29 + type Key: slotmap::Key; 30 + 31 + fn emit(self, ast: &mut Ast) -> Spanned<Self::Key>; 32 + } 33 + 34 + impl AstEntity for Spanned<Module> { 35 + type Key = key::Module; 36 + 37 + fn emit(self, ast: &mut Ast) -> Spanned<Self::Key> { 38 + self.span.spanned(ast.modules.insert(self)) 39 + } 40 + } 41 + 42 + impl AstEntity for Spanned<Expr> { 43 + type Key = key::Expr; 44 + 45 + fn emit(self, ast: &mut Ast) -> Spanned<Self::Key> { 46 + self.span.spanned(ast.exprs.insert(self)) 47 + } 48 + } 49 + 50 + impl AstEntity for Spanned<Func> { 51 + type Key = key::Func; 52 + 53 + fn emit(self, ast: &mut Ast) -> Spanned<Self::Key> { 54 + self.span.spanned(ast.funcs.insert(self)) 55 + } 56 + } 57 + 58 + #[derive(Debug, Clone)] 59 + pub struct Module { 60 + pub items: Vec<Spanned<ModuleItem>>, 61 + } 62 + 63 + #[derive(Debug, Clone)] 64 + pub enum ModuleItem { 65 + Func(key::Func), 66 + } 67 + 68 + #[derive(Debug, Clone)] 69 + pub struct Func { 70 + pub func_decl: FuncDecl, 71 + pub body: Vec<Spanned<key::Expr>>, 72 + } 73 + 74 + #[derive(Debug, Clone)] 75 + pub struct FuncDecl { 76 + pub func: Span, 77 + pub generics: Option<Generics>, 78 + pub name: Spanned<Word>, 79 + pub signature: FuncSignature, 80 + } 81 + 82 + #[derive(Clone)] 83 + pub struct Word(pub Intern<String>); 84 + 85 + impl std::fmt::Debug for Word { 86 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 87 + write!(f, "Word({})", self.0) 88 + } 89 + } 90 + 91 + #[derive(Debug, Clone, Eq, PartialEq)] 92 + pub enum Operator { 93 + And, 94 + Mul, 95 + Div, 96 + Plus, 97 + Minus, 98 + Assign, 99 + Eq, 100 + Dot, 101 + } 102 + 103 + #[derive(Debug, Clone)] 104 + pub struct Struct { 105 + pub struct_: Span, 106 + pub generics: Option<Generics>, 107 + pub name: Spanned<Word>, 108 + pub body: Vec<NameTypePair>, 109 + } 110 + 111 + #[derive(Debug, Clone)] 112 + pub struct Trait { 113 + pub trait_: Span, 114 + pub generics: Option<Generics>, 115 + pub name: Spanned<Word>, 116 + pub body: Vec<Spanned<FuncDecl>>, 117 + } 118 + 119 + #[derive(Debug, Clone)] 120 + pub struct StructLiteral { 121 + pub ty: Spanned<ItemPathBuf>, 122 + pub fields: Vec<FieldValuePair>, 123 + } 124 + 125 + #[derive(Debug, Clone)] 126 + pub struct Const { 127 + pub const_: Span, 128 + pub name: Spanned<Word>, 129 + pub signature: Spanned<Type>, 130 + pub assign: Spanned<Operator>, 131 + pub expr: Spanned<key::Expr>, 132 + } 133 + 134 + #[derive(Debug, Clone)] 135 + pub struct ModuleDef { 136 + pub module: Span, 137 + pub name: Spanned<Word>, 138 + } 139 + 140 + #[derive(Debug, Clone)] 141 + pub struct Use { 142 + pub use_: Span, 143 + pub path: Spanned<ItemPathBuf>, 144 + } 145 + 146 + #[derive(Clone, Debug)] 147 + pub struct Return { 148 + pub return_: Span, 149 + pub expr: Option<key::Expr>, 150 + } 151 + 152 + #[derive(Clone, Debug)] 153 + pub struct Lambda { 154 + pub lambda: Span, 155 + pub arglist: Vec<LambdaArg>, 156 + pub body: Vec<Spanned<key::Expr>>, 157 + } 158 + 159 + #[derive(Clone, Debug)] 160 + pub struct LambdaArg { 161 + pub name: Spanned<Word>, 162 + pub ascription: Option<Spanned<Type>>, 163 + } 164 + 165 + #[derive(Clone)] 166 + pub enum Expr { 167 + Return(Return), 168 + 169 + Let(Let), 170 + Lambda(Lambda), 171 + 172 + While(While), 173 + 174 + If(If), 175 + Cond(Match), 176 + 177 + Ref(Unary), 178 + Deref(Unary), 179 + 180 + Word(Word), 181 + Path(ItemPathBuf), 182 + 183 + Literal(Literal), 184 + FieldAccess(FieldAccess), 185 + Add(Binary), 186 + Sub(Binary), 187 + Mul(Binary), 188 + Div(Binary), 189 + Eq(Binary), 190 + Assign(Binary), 191 + Call(Call), 192 + 193 + Static(Static), 194 + Const(Const), 195 + } 196 + 197 + impl std::fmt::Debug for Expr { 198 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 199 + match self { 200 + Expr::Return(arg0) => arg0.fmt(f), 201 + Expr::Let(arg0) => arg0.fmt(f), 202 + Expr::Lambda(arg0) => arg0.fmt(f), 203 + Expr::While(arg0) => arg0.fmt(f), 204 + Expr::If(arg0) => arg0.fmt(f), 205 + Expr::Cond(arg0) => arg0.fmt(f), 206 + Expr::Word(arg0) => arg0.fmt(f), 207 + Expr::Path(arg0) => arg0.fmt(f), 208 + Expr::Literal(arg0) => arg0.fmt(f), 209 + Expr::FieldAccess(arg0) => arg0.fmt(f), 210 + Expr::Add(arg0) => arg0.fmt(f), 211 + Expr::Sub(arg0) => arg0.fmt(f), 212 + Expr::Mul(arg0) => arg0.fmt(f), 213 + Expr::Div(arg0) => arg0.fmt(f), 214 + Expr::Eq(arg0) => arg0.fmt(f), 215 + Expr::Assign(arg0) => arg0.fmt(f), 216 + Expr::Deref(arg0) => arg0.fmt(f), 217 + Expr::Ref(arg0) => arg0.fmt(f), 218 + Expr::Call(arg0) => arg0.fmt(f), 219 + Expr::Static(arg0) => arg0.fmt(f), 220 + Expr::Const(arg0) => arg0.fmt(f), 221 + } 222 + } 223 + } 224 + 225 + #[derive(Debug, Clone)] 226 + pub struct Call { 227 + pub callee: Spanned<key::Expr>, 228 + pub args: Vec<Spanned<key::Expr>>, 229 + } 230 + 231 + #[derive(Debug, Clone)] 232 + pub struct Binary { 233 + pub left: Spanned<key::Expr>, 234 + pub op: Spanned<Operator>, 235 + pub right: Spanned<key::Expr>, 236 + } 237 + 238 + #[derive(Debug, Clone)] 239 + pub struct Unary { 240 + pub op: Spanned<Operator>, 241 + pub expr: Spanned<key::Expr>, 242 + } 243 + 244 + #[derive(Debug, Clone)] 245 + pub struct Generics { 246 + pub tys: Vec<Generic>, 247 + } 248 + 249 + #[derive(Debug, Clone)] 250 + pub struct Generic { 251 + pub ty: Spanned<Word>, 252 + pub constraints: Vec<Spanned<ItemPathBuf>>, 253 + } 254 + 255 + #[derive(Debug, Clone, Eq, PartialEq)] 256 + pub struct GenericParams { 257 + pub tys: Vec<Spanned<Type>>, 258 + } 259 + 260 + #[derive(Debug, Clone)] 261 + pub struct FieldAccess { 262 + pub reciever: Spanned<key::Expr>, 263 + pub field: Spanned<Word>, 264 + } 265 + 266 + #[derive(Debug, Clone)] 267 + pub struct Static { 268 + pub static_: Span, 269 + pub name: Spanned<Word>, 270 + pub signature: Spanned<Type>, 271 + pub assign: Spanned<Operator>, 272 + pub expr: Spanned<key::Expr>, 273 + } 274 + 275 + #[derive(Debug, Clone)] 276 + pub struct FuncSignature { 277 + pub ins: Vec<NameTypePair>, 278 + pub return_: Option<Spanned<Type>>, 279 + } 280 + 281 + #[derive(Debug, Clone)] 282 + pub struct NameTypePair { 283 + pub name: Spanned<Word>, 284 + pub ty: Spanned<Type>, 285 + } 286 + 287 + #[derive(Debug, Clone)] 288 + pub struct FieldValuePair { 289 + pub name: Spanned<Word>, 290 + pub sep: Spanned<Operator>, 291 + pub expr: Spanned<key::Expr>, 292 + } 293 + 294 + #[derive(Debug, Clone)] 295 + pub struct While { 296 + pub while_: Span, 297 + pub cond: Spanned<key::Expr>, 298 + pub body: Vec<Spanned<key::Expr>>, 299 + } 300 + 301 + #[derive(Debug, Clone)] 302 + pub struct If { 303 + pub if_: Span, 304 + pub cond: Spanned<key::Expr>, 305 + pub truth: Vec<Spanned<key::Expr>>, 306 + pub lie: Option<Else>, 307 + } 308 + 309 + #[derive(Debug, Clone)] 310 + pub struct Else { 311 + pub else_: Span, 312 + pub body: Vec<Spanned<key::Expr>>, 313 + } 314 + 315 + #[derive(Debug, Clone)] 316 + pub struct Match { 317 + pub match_: Span, 318 + pub expr: Spanned<key::Expr>, 319 + pub branches: Vec<Spanned<MatchBranch>>, 320 + } 321 + 322 + #[derive(Debug, Clone)] 323 + pub struct MatchBranch { 324 + pub pat: Spanned<key::Expr>, 325 + pub fat_arrow: Spanned<Operator>, 326 + pub body: Vec<Spanned<key::Expr>>, 327 + } 328 + 329 + #[derive(Debug, Clone)] 330 + pub struct Let { 331 + pub let_: Span, 332 + pub pat: Spanned<Word>, 333 + pub ascription: Option<Spanned<Type>>, 334 + pub assign: Spanned<Operator>, 335 + pub body: Spanned<key::Expr>, 336 + } 337 + #[derive(Clone)] 338 + pub enum Literal { 339 + Bool(bool), 340 + Int(i64), 341 + UInt(u64), 342 + String(Intern<String>), 343 + Char(char), 344 + Struct(StructLiteral), 345 + Tuple(Vec<Spanned<key::Expr>>), 346 + Array(Vec<Spanned<key::Expr>>), 347 + } 348 + 349 + impl std::fmt::Debug for Literal { 350 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 351 + match self { 352 + Literal::Bool(arg0) => arg0.fmt(f), 353 + Literal::Int(arg0) => arg0.fmt(f), 354 + Literal::UInt(arg0) => arg0.fmt(f), 355 + Literal::String(arg0) => arg0.fmt(f), 356 + Literal::Char(arg0) => arg0.fmt(f), 357 + Literal::Struct(arg0) => arg0.fmt(f), 358 + Literal::Tuple(arg0) => write!(f, "({:?})", arg0), 359 + Literal::Array(arg0) => write!(f, "[{:?}]", arg0), 360 + } 361 + } 362 + } 363 + 364 + #[derive(Clone, Eq, PartialEq)] 365 + pub enum Type { 366 + Ptr(Box<Self>), 367 + Primitive(Primitive), 368 + Custom(Custom), 369 + } 370 + 371 + impl std::fmt::Debug for Type { 372 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 373 + self.type_name().fmt(f) 374 + } 375 + } 376 + 377 + impl Type { 378 + pub fn type_name(&self) -> ItemPathBuf { 379 + use std::fmt::Write; 380 + match self { 381 + Type::Ptr(box ty) => { 382 + let mut name = ty.type_name(); 383 + if let Some(s) = name.segment_mut(0) { 384 + *s = format!("&>{s}").into(); 385 + } 386 + name 387 + } 388 + Type::Primitive(p) => match p { 389 + Primitive::Void => path!(void), 390 + Primitive::Bool => path!(bool), 391 + Primitive::Char => path!(char), 392 + Primitive::U64 => path!(u64), 393 + Primitive::U32 => path!(u32), 394 + Primitive::U16 => path!(u16), 395 + Primitive::U8 => path!(u8), 396 + Primitive::I64 => path!(i64), 397 + Primitive::I32 => path!(i32), 398 + Primitive::I16 => path!(i16), 399 + Primitive::I8 => path!(i8), 400 + }, 401 + Type::Custom(Custom { name, params }) => { 402 + let mut base = name.clone(); 403 + if let Some(params) = params { 404 + let mut paramstr = String::from("["); 405 + for (i, param) in params.inner.tys.iter().enumerate() { 406 + if i == 0 { 407 + write!(paramstr, "{:?}", param.inner.type_name()).unwrap(); 408 + } else { 409 + write!(paramstr, " {:?}", param.inner.type_name()).unwrap(); 410 + } 411 + } 412 + write!(paramstr, "]").unwrap(); 413 + base.push(paramstr.into()); 414 + } 415 + base 416 + } 417 + } 418 + } 419 + } 420 + 421 + #[derive(Clone, Eq, PartialEq)] 422 + pub struct Custom { 423 + pub name: ItemPathBuf, 424 + pub params: Option<Spanned<GenericParams>>, 425 + } 426 + 427 + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 428 + pub enum Primitive { 429 + Void, 430 + 431 + Bool, 432 + Char, 433 + 434 + U64, 435 + U32, 436 + U16, 437 + U8, 438 + 439 + I64, 440 + I32, 441 + I16, 442 + I8, 443 + } 444 + 445 + impl Primitive { 446 + pub fn size(&self) -> usize { 447 + match self { 448 + Primitive::Void => 0, 449 + Primitive::Bool => 1, 450 + Primitive::Char => 1, 451 + Primitive::U64 => 8, 452 + Primitive::U32 => 4, 453 + Primitive::U16 => 2, 454 + Primitive::U8 => 1, 455 + Primitive::I64 => 8, 456 + Primitive::I32 => 4, 457 + Primitive::I16 => 2, 458 + Primitive::I8 => 1, 459 + } 460 + } 461 + }

+760

slate-frontend/src/parser/flat_parsers.rs

··· 1 + use std::path::PathBuf; 2 + 3 + use chumsky::{ 4 + input::{MapExtra, ValueInput}, 5 + pratt, 6 + prelude::*, 7 + primitive::select, 8 + }; 9 + use internment::Intern; 10 + use itempath::ItemPathBuf; 11 + use logos::Logos; 12 + use spanner::{Span, Spanned}; 13 + 14 + use crate::lexer::Token; 15 + 16 + use super::flat_ast::{ 17 + key, Ast, Binary, Call, Const, Custom, Expr, FieldAccess, Func, FuncDecl, FuncSignature, 18 + Generic, GenericParams, Generics, Let, Module, ModuleItem, NameTypePair, Operator, Primitive, 19 + Static, Type, Unary, Word, 20 + }; 21 + 22 + pub trait NakedParser<'i, I, O, S: 'static> 23 + where 24 + Self: Parser<'i, I, O, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 25 + I: ValueInput<'i, Token = Token, Span = Span>, 26 + { 27 + } 28 + impl<'i, I, O, T, S: 'static> NakedParser<'i, I, O, S> for T 29 + where 30 + T: Parser<'i, I, O, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 31 + I: ValueInput<'i, Token = Token, Span = Span>, 32 + { 33 + } 34 + 35 + pub trait FlatParser<'i, I, O, S: 'static> 36 + where 37 + Self: Parser<'i, I, Spanned<O>, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 38 + I: ValueInput<'i, Token = Token, Span = Span>, 39 + { 40 + } 41 + impl<'i, I, O, T, S: 'static> FlatParser<'i, I, O, S> for T 42 + where 43 + T: Parser<'i, I, Spanned<O>, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 44 + I: ValueInput<'i, Token = Token, Span = Span>, 45 + { 46 + } 47 + 48 + fn ty<'i, I>() -> impl FlatParser<'i, I, Type, Ast> 49 + where 50 + I: ValueInput<'i, Token = Token, Span = Span>, 51 + { 52 + recursive(|ty| { 53 + let generic_params = lbracket() 54 + .ignore_then(ty.repeated().collect()) 55 + .then_ignore(rbracket()) 56 + .map_with(|tys, span| Spanned { 57 + span: span.span(), 58 + inner: GenericParams { tys }, 59 + }); 60 + just(Token::OpAnd) 61 + .ignored() 62 + .repeated() 63 + .collect::<Vec<()>>() 64 + .then(path().then(generic_params.or_not())) 65 + .map_with(|(ptr, (ty, params)), span| { 66 + let mut ty = if let Some(type_name) = ty.inner.first() { 67 + match &**type_name { 68 + "void" => Type::Primitive(Primitive::Void), 69 + "bool" => Type::Primitive(Primitive::Bool), 70 + "char" => Type::Primitive(Primitive::Char), 71 + 72 + "u64" => Type::Primitive(Primitive::U64), 73 + "u32" => Type::Primitive(Primitive::U32), 74 + "u16" => Type::Primitive(Primitive::U16), 75 + "u8" => Type::Primitive(Primitive::U8), 76 + 77 + "i64" => Type::Primitive(Primitive::I64), 78 + "i32" => Type::Primitive(Primitive::I32), 79 + "i16" => Type::Primitive(Primitive::I16), 80 + "i8" => Type::Primitive(Primitive::I8), 81 + _ => Type::Custom(Custom { 82 + name: ty.inner, 83 + params, 84 + }), 85 + } 86 + } else { 87 + Type::Custom(Custom { 88 + name: ty.inner, 89 + params, 90 + }) 91 + }; 92 + for _ in ptr { 93 + ty = Type::Ptr(Box::new(ty)) 94 + } 95 + 96 + Spanned { 97 + span: span.span(), 98 + inner: ty, 99 + } 100 + }) 101 + }) 102 + } 103 + 104 + fn parse_string(s: &str, path: Intern<PathBuf>) -> Result<Intern<String>, Rich<'_, Token, Span>> { 105 + #[derive(Logos)] 106 + pub enum StrToken { 107 + #[regex(r"\\.", |l| l.slice().chars().nth(1))] 108 + Escaped(char), 109 + #[regex(r#"[^\\"]"#, |l| l.slice().chars().next())] 110 + Char(char), 111 + #[token(r#"""#)] 112 + End, 113 + } 114 + 115 + StrToken::lexer(s) 116 + .spanned() 117 + .filter_map(|(t, s)| match t.ok()? { 118 + StrToken::Escaped(c) => match c { 119 + 'n' => Some(Ok('\n')), 120 + 't' => Some(Ok('\t')), 121 + '"' => Some(Ok('"')), 122 + _ => Some(Err(Rich::custom( 123 + Span::new(path, s.start, s.end), 124 + "Invalid character escape", 125 + ))), 126 + }, 127 + StrToken::Char(c) => Some(Ok(c)), 128 + StrToken::End => None, 129 + }) 130 + .collect::<Result<String, _>>() 131 + .map(Into::into) 132 + } 133 + 134 + fn kw_module<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 135 + where 136 + I: ValueInput<'i, Token = Token, Span = Span>, 137 + { 138 + just(Token::KwModule).map_with(|_, extra| extra.span()) 139 + } 140 + 141 + fn kw_use<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 142 + where 143 + I: ValueInput<'i, Token = Token, Span = Span>, 144 + { 145 + just(Token::KwUse).map_with(|_, extra| extra.span()) 146 + } 147 + 148 + fn kw_trait<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 149 + where 150 + I: ValueInput<'i, Token = Token, Span = Span>, 151 + { 152 + just(Token::KwTrait).map_with(|_, extra| extra.span()) 153 + } 154 + 155 + fn kw_let<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 156 + where 157 + I: ValueInput<'i, Token = Token, Span = Span>, 158 + { 159 + just(Token::KwLet).map_with(|_, extra| extra.span()) 160 + } 161 + 162 + fn kw_lambda<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 163 + where 164 + I: ValueInput<'i, Token = Token, Span = Span>, 165 + { 166 + just(Token::KwLambda).map_with(|_, extra| extra.span()) 167 + } 168 + 169 + fn kw_while<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 170 + where 171 + I: ValueInput<'i, Token = Token, Span = Span>, 172 + { 173 + just(Token::KwWhile).map_with(|_, extra| extra.span()) 174 + } 175 + 176 + fn kw_for<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 177 + where 178 + I: ValueInput<'i, Token = Token, Span = Span>, 179 + { 180 + just(Token::KwFor).map_with(|_, extra| extra.span()) 181 + } 182 + 183 + fn kw_match<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 184 + where 185 + I: ValueInput<'i, Token = Token, Span = Span>, 186 + { 187 + just(Token::KwMatch).map_with(|_, extra| extra.span()) 188 + } 189 + fn kw_if<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 190 + where 191 + I: ValueInput<'i, Token = Token, Span = Span>, 192 + { 193 + just(Token::KwIf).map_with(|_, extra| extra.span()) 194 + } 195 + fn kw_else<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 196 + where 197 + I: ValueInput<'i, Token = Token, Span = Span>, 198 + { 199 + just(Token::KwElse).map_with(|_, extra| extra.span()) 200 + } 201 + 202 + fn kw_ret<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 203 + where 204 + I: ValueInput<'i, Token = Token, Span = Span>, 205 + { 206 + just(Token::KwReturn).map_with(|_, extra| extra.span()) 207 + } 208 + 209 + fn kw_func<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 210 + where 211 + I: ValueInput<'i, Token = Token, Span = Span>, 212 + { 213 + just(Token::KwFunc).map_with(|_, extra| extra.span()) 214 + } 215 + 216 + fn kw_const<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 217 + where 218 + I: ValueInput<'i, Token = Token, Span = Span>, 219 + { 220 + just(Token::KwConst).map_with(|_, extra| extra.span()) 221 + } 222 + 223 + fn kw_static<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 224 + where 225 + I: ValueInput<'i, Token = Token, Span = Span>, 226 + { 227 + just(Token::KwStatic).map_with(|_, extra| extra.span()) 228 + } 229 + 230 + fn kw_struct<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 231 + where 232 + I: ValueInput<'i, Token = Token, Span = Span>, 233 + { 234 + just(Token::KwStruct).map_with(|_, extra| extra.span()) 235 + } 236 + 237 + fn kw_impl<'i, I>() -> impl NakedParser<'i, I, Span, Ast> 238 + where 239 + I: ValueInput<'i, Token = Token, Span = Span>, 240 + { 241 + just(Token::KwImpl).map_with(|_, extra| extra.span()) 242 + } 243 + 244 + fn op_and<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 245 + where 246 + I: ValueInput<'i, Token = Token, Span = Span>, 247 + { 248 + just(Token::OpAnd).map_with(|_, extra| Spanned { 249 + span: extra.span(), 250 + inner: Operator::And, 251 + }) 252 + } 253 + 254 + fn op_mul<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 255 + where 256 + I: ValueInput<'i, Token = Token, Span = Span>, 257 + { 258 + just(Token::OpMul).map_with(|_, extra| Spanned { 259 + span: extra.span(), 260 + inner: Operator::Mul, 261 + }) 262 + } 263 + 264 + fn op_div<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 265 + where 266 + I: ValueInput<'i, Token = Token, Span = Span>, 267 + { 268 + just(Token::OpDiv).map_with(|_, extra| Spanned { 269 + span: extra.span(), 270 + inner: Operator::Div, 271 + }) 272 + } 273 + 274 + fn op_plus<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 275 + where 276 + I: ValueInput<'i, Token = Token, Span = Span>, 277 + { 278 + just(Token::OpPlus).map_with(|_, extra| Spanned { 279 + span: extra.span(), 280 + inner: Operator::Plus, 281 + }) 282 + } 283 + 284 + fn op_minus<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 285 + where 286 + I: ValueInput<'i, Token = Token, Span = Span>, 287 + { 288 + just(Token::OpMinus).map_with(|_, extra| Spanned { 289 + span: extra.span(), 290 + inner: Operator::Minus, 291 + }) 292 + } 293 + 294 + fn op_assign<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 295 + where 296 + I: ValueInput<'i, Token = Token, Span = Span>, 297 + { 298 + just(Token::OpAssign).map_with(|_, extra| Spanned { 299 + span: extra.span(), 300 + inner: Operator::Assign, 301 + }) 302 + } 303 + 304 + fn op_eq<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 305 + where 306 + I: ValueInput<'i, Token = Token, Span = Span>, 307 + { 308 + just(Token::OpEq).map_with(|_, extra| Spanned { 309 + span: extra.span(), 310 + inner: Operator::Eq, 311 + }) 312 + } 313 + 314 + fn op_dot<'i, I>() -> impl FlatParser<'i, I, Operator, Ast> 315 + where 316 + I: ValueInput<'i, Token = Token, Span = Span>, 317 + { 318 + just(Token::OpDot).map_with(|_, extra| Spanned { 319 + span: extra.span(), 320 + inner: Operator::Dot, 321 + }) 322 + } 323 + 324 + fn fat_arrow<'i, I>() -> impl NakedParser<'i, I, (), Ast> 325 + where 326 + I: ValueInput<'i, Token = Token, Span = Span>, 327 + { 328 + just(Token::FatArrow).ignored() 329 + } 330 + 331 + fn word<'i, I>() -> impl FlatParser<'i, I, Word, Ast> 332 + where 333 + I: ValueInput<'i, Token = Token, Span = Span>, 334 + { 335 + select! { 336 + Token::Word(w) = span => Spanned { span: span.span(), inner: Word(w) }, 337 + } 338 + } 339 + 340 + fn word_expr<'i, I>() -> impl FlatParser<'i, I, key::Expr, Ast> 341 + where 342 + I: ValueInput<'i, Token = Token, Span = Span>, 343 + { 344 + { 345 + chumsky::primitive::select( 346 + |t, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| match t { 347 + Token::Word(w) => { 348 + let expr = extra.span().spanned(Expr::Word(Word(w))); 349 + Option::Some(extra.state().insert(expr)) 350 + } 351 + _ => Option::None, 352 + }, 353 + ) 354 + } 355 + } 356 + 357 + fn path<'i, I>() -> impl FlatParser<'i, I, ItemPathBuf, Ast> 358 + where 359 + I: ValueInput<'i, Token = Token, Span = Span>, 360 + { 361 + select! { 362 + Token::Word(w) => w, 363 + } 364 + .separated_by(just(Token::DoubleColon)) 365 + .at_least(1) 366 + .collect::<Vec<_>>() 367 + .map_with(|ws, span| Spanned { 368 + span: span.span(), 369 + inner: ItemPathBuf::from(ws), 370 + }) 371 + } 372 + 373 + fn path_expr<'i, I>() -> impl FlatParser<'i, I, key::Expr, Ast> 374 + where 375 + I: ValueInput<'i, Token = Token, Span = Span>, 376 + { 377 + select! { 378 + Token::Word(w) => w, 379 + } 380 + .separated_by(just(Token::DoubleColon)) 381 + .at_least(1) 382 + .collect::<Vec<_>>() 383 + .map_with( 384 + |ws, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 385 + let expr = extra.span().spanned(Expr::Path(ItemPathBuf::from(ws))); 386 + extra.state().insert(expr) 387 + }, 388 + ) 389 + } 390 + 391 + fn separator<'i, I>() -> impl NakedParser<'i, I, (), Ast> 392 + where 393 + I: ValueInput<'i, Token = Token, Span = Span>, 394 + { 395 + just(Token::Colon).ignored() 396 + } 397 + 398 + fn const_<'i: 'd, 'd, I>( 399 + expr: impl FlatParser<'i, I, key::Expr, Ast>, 400 + ) -> impl FlatParser<'i, I, Const, Ast> 401 + where 402 + I: ValueInput<'i, Token = Token, Span = Span>, 403 + { 404 + kw_const() 405 + .then(word()) 406 + .then(type_ascription()) 407 + .then(op_assign()) 408 + .then(expr) 409 + .map_with( 410 + |((((const_, name), signature), assign), expr), span| Spanned { 411 + span: span.span(), 412 + inner: Const { 413 + const_, 414 + name, 415 + signature, 416 + assign, 417 + expr, 418 + }, 419 + }, 420 + ) 421 + } 422 + 423 + fn const_expr<'i, I>( 424 + expr: impl FlatParser<'i, I, key::Expr, Ast>, 425 + ) -> impl FlatParser<'i, I, key::Expr, Ast> 426 + where 427 + I: ValueInput<'i, Token = Token, Span = Span>, 428 + { 429 + const_(expr).map_with(|c, e| e.state().insert(c.map(Expr::Const))) 430 + } 431 + 432 + fn static_<'i, I>( 433 + expr: impl FlatParser<'i, I, key::Expr, Ast>, 434 + ) -> impl FlatParser<'i, I, Static, Ast> 435 + where 436 + I: ValueInput<'i, Token = Token, Span = Span>, 437 + { 438 + kw_static() 439 + .then(word()) 440 + .then(type_ascription()) 441 + .then(op_assign()) 442 + .then(expr) 443 + .map_with( 444 + |((((static_, name), signature), assign), expr), span| Spanned { 445 + span: span.span(), 446 + inner: Static { 447 + static_, 448 + name, 449 + signature, 450 + assign, 451 + expr, 452 + }, 453 + }, 454 + ) 455 + } 456 + 457 + fn static_expr<'i, I>( 458 + expr: impl FlatParser<'i, I, key::Expr, Ast>, 459 + ) -> impl FlatParser<'i, I, key::Expr, Ast> 460 + where 461 + I: ValueInput<'i, Token = Token, Span = Span>, 462 + { 463 + static_(expr).map_with(|c, e| e.state().insert(c.map(Expr::Static))) 464 + } 465 + 466 + fn expr<'i: 'd, 'd, I>() -> impl FlatParser<'i, I, key::Expr, Ast> 467 + where 468 + I: ValueInput<'i, Token = Token, Span = Span>, 469 + { 470 + recursive(|expr| { 471 + let let_ = kw_let() 472 + .then(word()) 473 + .then(type_ascription().or_not()) 474 + .then(op_assign()) 475 + .then(expr.clone()) 476 + .map_with(|((((let_, pat), ascription), assign), body), extra| { 477 + let expr = Spanned { 478 + span: extra.span(), 479 + inner: Expr::Let(Let { 480 + let_, 481 + pat, 482 + ascription, 483 + assign, 484 + body, 485 + }), 486 + }; 487 + extra.state().insert(expr) 488 + }); 489 + 490 + let call = lparen() 491 + .ignore_then( 492 + select! { Token::Indent(_) => () } 493 + .or_not() 494 + .ignore_then(expr.clone()) 495 + .separated_by(just(Token::Comma)) 496 + .allow_trailing() 497 + .collect::<Vec<Spanned<key::Expr>>>(), 498 + ) 499 + .then_ignore( 500 + select! { Token::Indent(_) => () } 501 + .or_not() 502 + .ignore_then(rparen()), 503 + ); 504 + 505 + choice(( 506 + static_expr(expr.clone()), 507 + const_expr(expr), 508 + path_expr(), 509 + word_expr(), 510 + )) 511 + .pratt(( 512 + pratt::prefix( 513 + 1, 514 + op_and::(), 515 + |op, expr, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 516 + let expr = extra.span().spanned(Expr::Ref(Unary { op, expr })); 517 + extra.state().insert(expr) 518 + }, 519 + ), 520 + pratt::infix( 521 + pratt::left(5), 522 + op_mul::(), 523 + |left, op, right, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 524 + let expr = extra.span().spanned(Expr::Mul(Binary { left, op, right })); 525 + extra.state().insert(expr) 526 + }, 527 + ), 528 + pratt::prefix( 529 + 1, 530 + op_mul::(), 531 + |op, expr, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 532 + let expr = extra.span().spanned(Expr::Deref(Unary { op, expr })); 533 + extra.state().insert(expr) 534 + }, 535 + ), 536 + pratt::infix( 537 + pratt::left(5), 538 + op_div::(), 539 + |left, op, right, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 540 + let expr = extra.span().spanned(Expr::Div(Binary { left, op, right })); 541 + extra.state().insert(expr) 542 + }, 543 + ), 544 + pratt::infix( 545 + pratt::left(4), 546 + op_plus::(), 547 + |left, op, right, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 548 + let expr = extra.span().spanned(Expr::Add(Binary { left, op, right })); 549 + extra.state().insert(expr) 550 + }, 551 + ), 552 + pratt::infix( 553 + pratt::left(4), 554 + op_minus::(), 555 + |left, op, right, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 556 + let expr = extra.span().spanned(Expr::Sub(Binary { left, op, right })); 557 + extra.state().insert(expr) 558 + }, 559 + ), 560 + pratt::infix( 561 + pratt::left(3), 562 + op_eq::(), 563 + |left, op, right, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 564 + let expr = extra.span().spanned(Expr::Eq(Binary { left, op, right })); 565 + extra.state().insert(expr) 566 + }, 567 + ), 568 + pratt::infix( 569 + pratt::left(3), 570 + op_assign::(), 571 + |left, op, right, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 572 + let expr = extra 573 + .span() 574 + .spanned(Expr::Assign(Binary { left, op, right })); 575 + extra.state().insert(expr) 576 + }, 577 + ), 578 + pratt::postfix( 579 + 6, 580 + select! { Token::Indent(_) => () } 581 + .or_not() 582 + .ignore_then(op_dot::().ignore_then(word())), 583 + |reciever, field, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 584 + let expr = extra 585 + .span() 586 + .spanned(Expr::FieldAccess(FieldAccess { reciever, field })); 587 + extra.state().insert(expr) 588 + }, 589 + ), 590 + pratt::postfix( 591 + 6, 592 + call, 593 + |callee, args, extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 594 + let expr = extra.span().spanned(Expr::Call(Call { callee, args })); 595 + extra.state().insert(expr) 596 + }, 597 + ), 598 + )) 599 + }) 600 + .labelled("Expr") 601 + } 602 + 603 + fn indent_increase<'i, I>() -> impl NakedParser<'i, I, usize, Ast> 604 + where 605 + I: ValueInput<'i, Token = Token, Span = Span>, 606 + { 607 + select(|x, e| match x { 608 + Token::Indent(level) if level > *e.ctx() => Some(level), 609 + _ => None, 610 + }) 611 + .labelled("indent increase") 612 + } 613 + 614 + fn indent_same<'i, I>() -> impl NakedParser<'i, I, (), Ast> 615 + where 616 + I: ValueInput<'i, Token = Token, Span = Span>, 617 + { 618 + select(|x, e| match x { 619 + Token::Indent(level) if level == *e.ctx() => Some(()), 620 + _ => None, 621 + }) 622 + .labelled("same indent") 623 + } 624 + fn func_signature<'i, I>() -> impl NakedParser<'i, I, FuncSignature, Ast> 625 + where 626 + I: ValueInput<'i, Token = Token, Span = Span>, 627 + { 628 + name_type_pair() 629 + .separated_by(just(Token::Comma)) 630 + .collect::<Vec<_>>() 631 + .then(fat_arrow().ignore_then(ty()).or_not()) 632 + .map(|(ins, return_)| FuncSignature { ins, return_ }) 633 + } 634 + 635 + fn lbracket<'i, I>() -> impl NakedParser<'i, I, (), Ast> 636 + where 637 + I: ValueInput<'i, Token = Token, Span = Span>, 638 + { 639 + just(Token::LBracket).ignored() 640 + } 641 + fn rbracket<'i, I>() -> impl NakedParser<'i, I, (), Ast> 642 + where 643 + I: ValueInput<'i, Token = Token, Span = Span>, 644 + { 645 + just(Token::RBracket).ignored() 646 + } 647 + 648 + fn lparen<'i, I>() -> impl NakedParser<'i, I, (), Ast> 649 + where 650 + I: ValueInput<'i, Token = Token, Span = Span>, 651 + { 652 + just(Token::LParen).ignored() 653 + } 654 + fn rparen<'i, I>() -> impl NakedParser<'i, I, (), Ast> 655 + where 656 + I: ValueInput<'i, Token = Token, Span = Span>, 657 + { 658 + just(Token::RParen).ignored() 659 + } 660 + 661 + fn generics<'i, I>() -> impl NakedParser<'i, I, Generics, Ast> 662 + where 663 + I: ValueInput<'i, Token = Token, Span = Span>, 664 + { 665 + lbracket() 666 + .ignore_then( 667 + word() 668 + .then( 669 + separator() 670 + .ignore_then(path().separated_by(just(Token::OpPlus)).collect()) 671 + .or_not(), 672 + ) 673 + .map(|(ty, constraints)| Generic { 674 + ty, 675 + constraints: constraints.unwrap_or_default(), 676 + }) 677 + .separated_by(just(Token::Comma)) 678 + .collect::<Vec<_>>(), 679 + ) 680 + .then_ignore(rbracket()) 681 + .map(|tys| Generics { tys }) 682 + } 683 + 684 + fn body<'i: 'd, 'd, I, O>( 685 + expr: impl NakedParser<'i, I, Spanned<O>, Ast>, 686 + ) -> impl NakedParser<'i, I, Vec<Spanned<O>>, Ast> 687 + where 688 + I: ValueInput<'i, Token = Token, Span = Span>, 689 + { 690 + indent_increase().ignore_with_ctx(expr.clone().separated_by(indent_same()).collect::<Vec<_>>()) 691 + } 692 + 693 + fn body_unspanned<'i: 'd, 'd, I, O>( 694 + expr: impl NakedParser<'i, I, O, Ast>, 695 + ) -> impl NakedParser<'i, I, Vec<O>, Ast> 696 + where 697 + I: ValueInput<'i, Token = Token, Span = Span>, 698 + { 699 + indent_increase().ignore_with_ctx(expr.clone().separated_by(indent_same()).collect::<Vec<_>>()) 700 + } 701 + 702 + fn func<'i: 'd, 'd, I>() -> impl FlatParser<'i, I, key::Func, Ast> 703 + where 704 + I: ValueInput<'i, Token = Token, Span = Span>, 705 + { 706 + func_decl().then(body(expr())).map_with( 707 + |(func_decl, body), extra: &mut MapExtra<'i, '_, I, extra::Full<_, Ast, _>>| { 708 + let func = extra.span().spanned(Func { func_decl, body }); 709 + extra.state().insert(func) 710 + }, 711 + ) 712 + } 713 + 714 + fn func_decl<'i: 'd, 'd, I>() -> impl NakedParser<'i, I, FuncDecl, Ast> 715 + where 716 + I: ValueInput<'i, Token = Token, Span = Span>, 717 + { 718 + kw_func() 719 + .then(generics().or_not()) 720 + .then(word()) 721 + .then(func_signature()) 722 + .map(|(((func, generics), name), signature)| FuncDecl { 723 + func, 724 + generics, 725 + name, 726 + signature, 727 + }) 728 + } 729 + 730 + fn type_ascription<'i, I>() -> impl FlatParser<'i, I, Type, Ast> 731 + where 732 + I: ValueInput<'i, Token = Token, Span = Span>, 733 + { 734 + separator().ignore_then(ty()) 735 + } 736 + 737 + fn name_type_pair<'i, I>() -> impl NakedParser<'i, I, NameTypePair, Ast> 738 + where 739 + I: ValueInput<'i, Token = Token, Span = Span>, 740 + { 741 + word() 742 + .then(type_ascription()) 743 + .map(|(name, ty)| NameTypePair { name, ty }) 744 + } 745 + 746 + pub fn file<'i, I>() -> impl FlatParser<'i, I, key::Module, Ast> 747 + where 748 + I: ValueInput<'i, Token = Token, Span = Span>, 749 + { 750 + choice((func().map(|f| f.map(ModuleItem::Func)),)) 751 + .padded_by(select!(Token::Indent(_) => ()).or_not()) 752 + .repeated() 753 + .collect() 754 + .then_ignore(end()) 755 + .or(end().to(vec![])) 756 + .map_with(|items, extra: &mut MapExtra<'i, '_, I, _>| { 757 + let module = extra.span().spanned(Module { items }); 758 + extra.state().insert(module) 759 + }) 760 + }

+150 -130

slate-frontend/src/parser/parsers.rs

··· 15 15 16 16 use super::{ 17 17 ast::{ 18 - key, Ast, Binary, Call, Const, Constraint, Else, Expr, FieldAccess, FieldValuePair, Func, 19 - FuncDecl, FuncSignature, Generic, GenericParams, Generics, If, ImplLevel, InherentImpl, 20 - Keyword, Lambda, LambdaArg, Let, Literal, Match, MatchBranch, Module, ModuleDef, 21 - NameTypePair, Punctuation, Return, SignatureReturn, Static, Struct, StructLiteral, 22 - TopLevel, Trait, TraitImpl, TypeAscription, Unary, Use, While, Word, 18 + Binary, Call, Const, Constraint, Else, Expr, FieldAccess, FieldValuePair, Func, FuncDecl, 19 + FuncSignature, Generic, GenericParams, Generics, If, ImplLevel, InherentImpl, Keyword, 20 + Lambda, LambdaArg, Let, Literal, Match, MatchBranch, Module, ModuleDef, NameTypePair, 21 + Punctuation, Return, SignatureReturn, Static, Struct, StructLiteral, TopLevel, Trait, 22 + TraitImpl, TypeAscription, Unary, Use, While, Word, 23 23 }, 24 24 types::{Custom, Primitive, Type}, 25 25 }; 26 26 27 - pub trait NParser<'i, I, O, S: 'static> 27 + pub trait NParser<'i, I, O> 28 28 where 29 - Self: Parser<'i, I, O, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 29 + Self: Parser<'i, I, O, extra::Full<Rich<'i, Token, Span>, (), usize>> + Clone, 30 30 I: ValueInput<'i, Token = Token, Span = Span>, 31 31 { 32 32 } 33 - impl<'i, I, O, T, S: 'static> NParser<'i, I, O, S> for T 33 + impl<'i, I, O, T> NParser<'i, I, O> for T 34 34 where 35 - T: Parser<'i, I, O, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 35 + T: Parser<'i, I, O, extra::Full<Rich<'i, Token, Span>, (), usize>> + Clone, 36 36 I: ValueInput<'i, Token = Token, Span = Span>, 37 37 { 38 38 } 39 39 40 - trait SParser<'i, I, O, S: 'static> 40 + trait SParser<'i, I, O> 41 41 where 42 - Self: Parser<'i, I, Spanned<O>, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 42 + Self: Parser<'i, I, Spanned<O>, extra::Full<Rich<'i, Token, Span>, (), usize>> + Clone, 43 43 I: ValueInput<'i, Token = Token, Span = Span>, 44 44 { 45 45 } 46 - impl<'i, I, O, T, S: 'static> SParser<'i, I, O, S> for T 46 + impl<'i, I, O, T> SParser<'i, I, O> for T 47 47 where 48 - T: Parser<'i, I, Spanned<O>, extra::Full<Rich<'i, Token, Span>, S, usize>> + Clone, 48 + T: Parser<'i, I, Spanned<O>, extra::Full<Rich<'i, Token, Span>, (), usize>> + Clone, 49 49 I: ValueInput<'i, Token = Token, Span = Span>, 50 50 { 51 51 } 52 52 53 - fn ty<'i, I>() -> impl SParser<'i, I, Type, Ast> 53 + fn ty<'i, I>() -> impl SParser<'i, I, Type> 54 54 where 55 55 I: ValueInput<'i, Token = Token, Span = Span>, 56 56 { ··· 140 140 .map(Into::into) 141 141 } 142 142 143 - fn literal<'i, I>(expr: impl SParser<'i, I, Expr, Ast>) -> impl SParser<'i, I, Literal, Ast> 143 + fn literal<'i, I>(expr: impl SParser<'i, I, Expr>) -> impl SParser<'i, I, Literal> 144 144 where 145 145 I: ValueInput<'i, Token = Token, Span = Span>, 146 146 { ··· 222 222 .labelled("Literal") 223 223 } 224 224 225 - fn literal_expr<'i, I>(expr: impl SParser<'i, I, Expr, Ast>) -> impl SParser<'i, I, Expr, Ast> 225 + fn literal_expr<'i, I>(expr: impl SParser<'i, I, Expr>) -> impl SParser<'i, I, Expr> 226 226 where 227 227 I: ValueInput<'i, Token = Token, Span = Span>, 228 228 { ··· 232 232 }) 233 233 } 234 234 235 - fn kw_module<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 235 + fn kw_module<'i, I>() -> impl SParser<'i, I, Keyword> 236 236 where 237 237 I: ValueInput<'i, Token = Token, Span = Span>, 238 238 { ··· 242 242 }) 243 243 } 244 244 245 - fn kw_use<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 245 + fn kw_use<'i, I>() -> impl SParser<'i, I, Keyword> 246 246 where 247 247 I: ValueInput<'i, Token = Token, Span = Span>, 248 248 { ··· 252 252 }) 253 253 } 254 254 255 - fn kw_trait<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 255 + fn kw_trait<'i, I>() -> impl SParser<'i, I, Keyword> 256 256 where 257 257 I: ValueInput<'i, Token = Token, Span = Span>, 258 258 { ··· 262 262 }) 263 263 } 264 264 265 - fn kw_let<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 265 + fn kw_let<'i, I>() -> impl SParser<'i, I, Keyword> 266 266 where 267 267 I: ValueInput<'i, Token = Token, Span = Span>, 268 268 { ··· 272 272 }) 273 273 } 274 274 275 - fn kw_lambda<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 275 + fn kw_lambda<'i, I>() -> impl SParser<'i, I, Keyword> 276 276 where 277 277 I: ValueInput<'i, Token = Token, Span = Span>, 278 278 { ··· 282 282 }) 283 283 } 284 284 285 - fn kw_while<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 285 + fn kw_while<'i, I>() -> impl SParser<'i, I, Keyword> 286 286 where 287 287 I: ValueInput<'i, Token = Token, Span = Span>, 288 288 { ··· 292 292 }) 293 293 } 294 294 295 - fn kw_for<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 295 + fn kw_for<'i, I>() -> impl SParser<'i, I, Keyword> 296 296 where 297 297 I: ValueInput<'i, Token = Token, Span = Span>, 298 298 { ··· 302 302 }) 303 303 } 304 304 305 - fn kw_match<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 305 + fn kw_match<'i, I>() -> impl SParser<'i, I, Keyword> 306 306 where 307 307 I: ValueInput<'i, Token = Token, Span = Span>, 308 308 { ··· 311 311 inner: Keyword::Match, 312 312 }) 313 313 } 314 - fn kw_if<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 314 + fn kw_if<'i, I>() -> impl SParser<'i, I, Keyword> 315 315 where 316 316 I: ValueInput<'i, Token = Token, Span = Span>, 317 317 { ··· 320 320 inner: Keyword::If, 321 321 }) 322 322 } 323 - fn kw_else<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 323 + fn kw_else<'i, I>() -> impl SParser<'i, I, Keyword> 324 324 where 325 325 I: ValueInput<'i, Token = Token, Span = Span>, 326 326 { ··· 330 330 }) 331 331 } 332 332 333 - fn kw_ret<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 333 + fn kw_ret<'i, I>() -> impl SParser<'i, I, Keyword> 334 334 where 335 335 I: ValueInput<'i, Token = Token, Span = Span>, 336 336 { ··· 340 340 }) 341 341 } 342 342 343 - fn kw_func<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 343 + fn kw_func<'i, I>() -> impl SParser<'i, I, Keyword> 344 344 where 345 345 I: ValueInput<'i, Token = Token, Span = Span>, 346 346 { ··· 350 350 }) 351 351 } 352 352 353 - fn kw_const<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 353 + fn kw_const<'i, I>() -> impl SParser<'i, I, Keyword> 354 354 where 355 355 I: ValueInput<'i, Token = Token, Span = Span>, 356 356 { ··· 360 360 }) 361 361 } 362 362 363 - fn kw_static<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 363 + fn kw_static<'i, I>() -> impl SParser<'i, I, Keyword> 364 364 where 365 365 I: ValueInput<'i, Token = Token, Span = Span>, 366 366 { ··· 370 370 }) 371 371 } 372 372 373 - fn kw_struct<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 373 + fn kw_struct<'i, I>() -> impl SParser<'i, I, Keyword> 374 374 where 375 375 I: ValueInput<'i, Token = Token, Span = Span>, 376 376 { ··· 380 380 }) 381 381 } 382 382 383 - fn kw_impl<'i, I>() -> impl SParser<'i, I, Keyword, Ast> 383 + fn kw_impl<'i, I>() -> impl SParser<'i, I, Keyword> 384 384 where 385 385 I: ValueInput<'i, Token = Token, Span = Span>, 386 386 { ··· 390 390 }) 391 391 } 392 392 393 - fn op_and<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 393 + fn op_and<'i, I>() -> impl SParser<'i, I, Punctuation> 394 394 where 395 395 I: ValueInput<'i, Token = Token, Span = Span>, 396 396 { ··· 400 400 }) 401 401 } 402 402 403 - fn op_mul<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 403 + fn op_mul<'i, I>() -> impl SParser<'i, I, Punctuation> 404 404 where 405 405 I: ValueInput<'i, Token = Token, Span = Span>, 406 406 { ··· 410 410 }) 411 411 } 412 412 413 - fn op_div<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 413 + fn op_div<'i, I>() -> impl SParser<'i, I, Punctuation> 414 414 where 415 415 I: ValueInput<'i, Token = Token, Span = Span>, 416 416 { ··· 420 420 }) 421 421 } 422 422 423 - fn op_plus<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 423 + fn op_plus<'i, I>() -> impl SParser<'i, I, Punctuation> 424 424 where 425 425 I: ValueInput<'i, Token = Token, Span = Span>, 426 426 { ··· 430 430 }) 431 431 } 432 432 433 - fn op_minus<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 433 + fn op_minus<'i, I>() -> impl SParser<'i, I, Punctuation> 434 434 where 435 435 I: ValueInput<'i, Token = Token, Span = Span>, 436 436 { ··· 440 440 }) 441 441 } 442 442 443 - fn op_assign<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 443 + fn op_assign<'i, I>() -> impl SParser<'i, I, Punctuation> 444 444 where 445 445 I: ValueInput<'i, Token = Token, Span = Span>, 446 446 { ··· 450 450 }) 451 451 } 452 452 453 - fn op_eq<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 453 + fn op_eq<'i, I>() -> impl SParser<'i, I, Punctuation> 454 454 where 455 455 I: ValueInput<'i, Token = Token, Span = Span>, 456 456 { ··· 460 460 }) 461 461 } 462 462 463 - fn op_dot<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 463 + fn op_dot<'i, I>() -> impl SParser<'i, I, Punctuation> 464 464 where 465 465 I: ValueInput<'i, Token = Token, Span = Span>, 466 466 { ··· 470 470 }) 471 471 } 472 472 473 - fn fat_arrow<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 473 + fn fat_arrow<'i, I>() -> impl SParser<'i, I, Punctuation> 474 474 where 475 475 I: ValueInput<'i, Token = Token, Span = Span>, 476 476 { ··· 480 480 }) 481 481 } 482 482 483 - fn word<'i, I>() -> impl SParser<'i, I, Word, Ast> 483 + fn word<'i, I>() -> impl SParser<'i, I, Word> 484 484 where 485 485 I: ValueInput<'i, Token = Token, Span = Span>, 486 486 { ··· 489 489 } 490 490 } 491 491 492 - fn word_expr<'i, I>() -> impl SParser<'i, I, Expr, Ast> 492 + fn word_expr<'i, I>() -> impl SParser<'i, I, Expr> 493 493 where 494 494 I: ValueInput<'i, Token = Token, Span = Span>, 495 495 { ··· 498 498 } 499 499 } 500 500 501 - fn path<'i, I>() -> impl SParser<'i, I, ItemPathBuf, Ast> 501 + fn path<'i, I>() -> impl SParser<'i, I, ItemPathBuf> 502 502 where 503 503 I: ValueInput<'i, Token = Token, Span = Span>, 504 504 { ··· 514 514 }) 515 515 } 516 516 517 - fn path_expr<'i, I>() -> impl SParser<'i, I, Expr, Ast> 517 + fn path_expr<'i, I>() -> impl SParser<'i, I, Expr> 518 518 where 519 519 I: ValueInput<'i, Token = Token, Span = Span>, 520 520 { ··· 530 530 }) 531 531 } 532 532 533 - fn separator<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 533 + fn separator<'i, I>() -> impl SParser<'i, I, Punctuation> 534 534 where 535 535 I: ValueInput<'i, Token = Token, Span = Span>, 536 536 { ··· 540 540 }) 541 541 } 542 542 543 - fn const_<'i: 'd, 'd, I>(expr: impl SParser<'i, I, Expr, Ast>) -> impl SParser<'i, I, Const, Ast> 543 + fn const_<'i: 'd, 'd, I>(expr: impl SParser<'i, I, Expr>) -> impl SParser<'i, I, Const> 544 544 where 545 545 I: ValueInput<'i, Token = Token, Span = Span>, 546 546 { ··· 563 563 ) 564 564 } 565 565 566 - fn const_toplevel<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 566 + fn const_toplevel<'i, I>() -> impl SParser<'i, I, TopLevel> 567 567 where 568 568 I: ValueInput<'i, Token = Token, Span = Span>, 569 569 { ··· 573 573 }) 574 574 } 575 575 576 - fn const_expr<'i, I>(expr: impl SParser<'i, I, Expr, Ast>) -> impl SParser<'i, I, Expr, Ast> 576 + fn const_expr<'i, I>(expr: impl SParser<'i, I, Expr>) -> impl SParser<'i, I, Expr> 577 577 where 578 578 I: ValueInput<'i, Token = Token, Span = Span>, 579 579 { ··· 583 583 }) 584 584 } 585 585 586 - fn static_<'i, I>(expr: impl SParser<'i, I, Expr, Ast>) -> impl SParser<'i, I, Static, Ast> 586 + fn static_<'i, I>(expr: impl SParser<'i, I, Expr>) -> impl SParser<'i, I, Static> 587 587 where 588 588 I: ValueInput<'i, Token = Token, Span = Span>, 589 589 { ··· 606 606 ) 607 607 } 608 608 609 - fn static_toplevel<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 609 + fn static_toplevel<'i, I>() -> impl SParser<'i, I, TopLevel> 610 610 where 611 611 I: ValueInput<'i, Token = Token, Span = Span>, 612 612 { ··· 616 616 }) 617 617 } 618 618 619 - fn static_expr<'i, I>(expr: impl SParser<'i, I, Expr, Ast>) -> impl SParser<'i, I, Expr, Ast> 619 + fn static_expr<'i, I>(expr: impl SParser<'i, I, Expr>) -> impl SParser<'i, I, Expr> 620 620 where 621 621 I: ValueInput<'i, Token = Token, Span = Span>, 622 622 { ··· 626 626 }) 627 627 } 628 628 629 - fn expr<'i: 'd, 'd, I>() -> impl SParser<'i, I, Expr, Ast> 629 + fn expr<'i: 'd, 'd, I>() -> impl SParser<'i, I, Expr> 630 630 where 631 631 I: ValueInput<'i, Token = Token, Span = Span>, 632 632 { ··· 757 757 ret_expr, 758 758 )) 759 759 .pratt(( 760 - pratt::prefix(1, op_and::(), |op, expr, span| Spanned { 761 - span, 762 - inner: Expr::Ref(Box::new(Unary { op, expr })), 763 - }), 764 - pratt::infix(pratt::left(5), op_mul::(), |left, op, right, span| { 765 - Spanned { 766 - span, 760 + pratt::prefix( 761 + 1, 762 + op_and::(), 763 + |op, expr, span: &mut MapExtra<'i, '_, I, _>| Spanned { 764 + span: span.span(), 765 + inner: Expr::Ref(Box::new(Unary { op, expr })), 766 + }, 767 + ), 768 + pratt::infix( 769 + pratt::left(5), 770 + op_mul::(), 771 + |left, op, right, span: &mut MapExtra<'i, '_, I, _>| Spanned { 772 + span: span.span(), 767 773 inner: Expr::Mul(Box::new(Binary { left, op, right })), 768 - } 769 - }), 770 - pratt::prefix(1, op_mul::(), |op, expr, span| Spanned { 771 - span, 772 - inner: Expr::Deref(Box::new(Unary { op, expr })), 773 - }), 774 - pratt::infix(pratt::left(5), op_div::(), |left, op, right, span| { 775 - Spanned { 776 - span, 774 + }, 775 + ), 776 + pratt::prefix( 777 + 1, 778 + op_mul::(), 779 + |op, expr, span: &mut MapExtra<'i, '_, I, _>| Spanned { 780 + span: span.span(), 781 + inner: Expr::Deref(Box::new(Unary { op, expr })), 782 + }, 783 + ), 784 + pratt::infix( 785 + pratt::left(5), 786 + op_div::(), 787 + |left, op, right, span: &mut MapExtra<'i, '_, I, _>| Spanned { 788 + span: span.span(), 777 789 inner: Expr::Div(Box::new(Binary { left, op, right })), 778 - } 779 - }), 780 - pratt::infix(pratt::left(4), op_plus::(), |left, op, right, span| { 781 - Spanned { 782 - span, 790 + }, 791 + ), 792 + pratt::infix( 793 + pratt::left(4), 794 + op_plus::(), 795 + |left, op, right, span: &mut MapExtra<'i, '_, I, _>| Spanned { 796 + span: span.span(), 783 797 inner: Expr::Add(Box::new(Binary { left, op, right })), 784 - } 785 - }), 786 - pratt::infix(pratt::left(4), op_minus::(), |left, op, right, span| { 787 - Spanned { 788 - span, 798 + }, 799 + ), 800 + pratt::infix( 801 + pratt::left(4), 802 + op_minus::(), 803 + |left, op, right, span: &mut MapExtra<'i, '_, I, _>| Spanned { 804 + span: span.span(), 789 805 inner: Expr::Sub(Box::new(Binary { left, op, right })), 790 - } 791 - }), 792 - pratt::infix(pratt::left(3), op_eq::(), |left, op, right, span| { 793 - Spanned { 794 - span, 806 + }, 807 + ), 808 + pratt::infix( 809 + pratt::left(3), 810 + op_eq::(), 811 + |left, op, right, span: &mut MapExtra<'i, '_, I, _>| Spanned { 812 + span: span.span(), 795 813 inner: Expr::Eq(Box::new(Binary { left, op, right })), 796 - } 797 - }), 798 - pratt::infix(pratt::left(3), op_assign::(), |left, op, right, span| { 799 - Spanned { 800 - span, 814 + }, 815 + ), 816 + pratt::infix( 817 + pratt::left(3), 818 + op_assign::(), 819 + |left, op, right, span: &mut MapExtra<'i, '_, I, _>| Spanned { 820 + span: span.span(), 801 821 inner: Expr::Assign(Box::new(Binary { left, op, right })), 802 - } 803 - }), 822 + }, 823 + ), 804 824 pratt::postfix( 805 825 6, 806 826 select! { Token::Indent(_) => () } 807 827 .or_not() 808 828 .ignore_then(op_dot::().then(word())), 809 - |expr, (op, field), span| Spanned { 810 - span, 829 + |expr, (op, field), span: &mut MapExtra<'i, '_, I, _>| Spanned { 830 + span: span.span(), 811 831 inner: Expr::FieldAccess(Box::new(FieldAccess { 812 832 reciever: expr, 813 833 access: op, ··· 815 835 })), 816 836 }, 817 837 ), 818 - pratt::postfix(6, call, |callee, ((lparen, args), rparen), span| Spanned { 819 - span, 820 - inner: Expr::Call(Box::new(Call { 821 - callee, 822 - lparen, 823 - args, 824 - rparen, 825 - })), 826 - }), 838 + pratt::postfix( 839 + 6, 840 + call, 841 + |callee, ((lparen, args), rparen), span: &mut MapExtra<'i, '_, I, _>| Spanned { 842 + span: span.span(), 843 + inner: Expr::Call(Box::new(Call { 844 + callee, 845 + lparen, 846 + args, 847 + rparen, 848 + })), 849 + }, 850 + ), 827 851 )) 828 852 }) 829 853 .labelled("Expr") 830 854 } 831 855 832 - fn indent_increase<'i, I>() -> impl NParser<'i, I, usize, Ast> 856 + fn indent_increase<'i, I>() -> impl NParser<'i, I, usize> 833 857 where 834 858 I: ValueInput<'i, Token = Token, Span = Span>, 835 859 { ··· 840 864 .labelled("indent increase") 841 865 } 842 866 843 - fn indent_same<'i, I>() -> impl NParser<'i, I, (), Ast> 867 + fn indent_same<'i, I>() -> impl NParser<'i, I, ()> 844 868 where 845 869 I: ValueInput<'i, Token = Token, Span = Span>, 846 870 { ··· 850 874 }) 851 875 .labelled("same indent") 852 876 } 853 - fn func_signature<'i, I>() -> impl NParser<'i, I, FuncSignature, Ast> 877 + fn func_signature<'i, I>() -> impl NParser<'i, I, FuncSignature> 854 878 where 855 879 I: ValueInput<'i, Token = Token, Span = Span>, 856 880 { ··· 866 890 .map(|(ins, return_)| FuncSignature { ins, return_ }) 867 891 } 868 892 869 - fn lbracket<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 893 + fn lbracket<'i, I>() -> impl SParser<'i, I, Punctuation> 870 894 where 871 895 I: ValueInput<'i, Token = Token, Span = Span>, 872 896 { ··· 875 899 inner: Punctuation::LBracket, 876 900 }) 877 901 } 878 - fn rbracket<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 902 + fn rbracket<'i, I>() -> impl SParser<'i, I, Punctuation> 879 903 where 880 904 I: ValueInput<'i, Token = Token, Span = Span>, 881 905 { ··· 885 909 }) 886 910 } 887 911 888 - fn lparen<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 912 + fn lparen<'i, I>() -> impl SParser<'i, I, Punctuation> 889 913 where 890 914 I: ValueInput<'i, Token = Token, Span = Span>, 891 915 { ··· 894 918 inner: Punctuation::RParen, 895 919 }) 896 920 } 897 - fn rparen<'i, I>() -> impl SParser<'i, I, Punctuation, Ast> 921 + fn rparen<'i, I>() -> impl SParser<'i, I, Punctuation> 898 922 where 899 923 I: ValueInput<'i, Token = Token, Span = Span>, 900 924 { ··· 904 928 }) 905 929 } 906 930 907 - fn generics<'i, I>() -> impl NParser<'i, I, Generics, Ast> 931 + fn generics<'i, I>() -> impl NParser<'i, I, Generics> 908 932 where 909 933 I: ValueInput<'i, Token = Token, Span = Span>, 910 934 { ··· 930 954 } 931 955 932 956 fn body<'i: 'd, 'd, I, O>( 933 - expr: impl NParser<'i, I, Spanned<O>, Ast>, 934 - ) -> impl NParser<'i, I, Vec<Spanned<O>>, Ast> 957 + expr: impl NParser<'i, I, Spanned<O>>, 958 + ) -> impl NParser<'i, I, Vec<Spanned<O>>> 935 959 where 936 960 I: ValueInput<'i, Token = Token, Span = Span>, 937 961 { 938 962 indent_increase().ignore_with_ctx(expr.clone().separated_by(indent_same()).collect::<Vec<_>>()) 939 963 } 940 964 941 - fn body_unspanned<'i: 'd, 'd, I, O>( 942 - expr: impl NParser<'i, I, O, Ast>, 943 - ) -> impl NParser<'i, I, Vec<O>, Ast> 965 + fn body_unspanned<'i: 'd, 'd, I, O>(expr: impl NParser<'i, I, O>) -> impl NParser<'i, I, Vec<O>> 944 966 where 945 967 I: ValueInput<'i, Token = Token, Span = Span>, 946 968 { 947 969 indent_increase().ignore_with_ctx(expr.clone().separated_by(indent_same()).collect::<Vec<_>>()) 948 970 } 949 971 950 - fn func<'i: 'd, 'd, I>() -> impl SParser<'i, I, Func, Ast> 972 + fn func<'i: 'd, 'd, I>() -> impl SParser<'i, I, Func> 951 973 where 952 974 I: ValueInput<'i, Token = Token, Span = Span>, 953 975 { ··· 959 981 }) 960 982 } 961 983 962 - fn func_decl<'i: 'd, 'd, I>() -> impl NParser<'i, I, FuncDecl, Ast> 984 + fn func_decl<'i: 'd, 'd, I>() -> impl NParser<'i, I, FuncDecl> 963 985 where 964 986 I: ValueInput<'i, Token = Token, Span = Span>, 965 987 { ··· 975 997 }) 976 998 } 977 999 978 - fn type_ascription<'i, I>() -> impl NParser<'i, I, TypeAscription, Ast> 1000 + fn type_ascription<'i, I>() -> impl NParser<'i, I, TypeAscription> 979 1001 where 980 1002 I: ValueInput<'i, Token = Token, Span = Span>, 981 1003 { ··· 984 1006 .map(|(sep, ty)| TypeAscription { sep, ty }) 985 1007 } 986 1008 987 - fn name_type_pair<'i, I>() -> impl NParser<'i, I, NameTypePair, Ast> 1009 + fn name_type_pair<'i, I>() -> impl NParser<'i, I, NameTypePair> 988 1010 where 989 1011 I: ValueInput<'i, Token = Token, Span = Span>, 990 1012 { ··· 993 1015 .map(|(name, TypeAscription { sep, ty })| NameTypePair { name, sep, ty }) 994 1016 } 995 1017 996 - fn field_value_pair<'i, I>( 997 - expr: impl SParser<'i, I, Expr, Ast>, 998 - ) -> impl NParser<'i, I, FieldValuePair, Ast> 1018 + fn field_value_pair<'i, I>(expr: impl SParser<'i, I, Expr>) -> impl NParser<'i, I, FieldValuePair> 999 1019 where 1000 1020 I: ValueInput<'i, Token = Token, Span = Span>, 1001 1021 { ··· 1005 1025 .map(|((name, sep), expr)| FieldValuePair { name, sep, expr }) 1006 1026 } 1007 1027 1008 - fn struct_<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 1028 + fn struct_<'i, I>() -> impl SParser<'i, I, TopLevel> 1009 1029 where 1010 1030 I: ValueInput<'i, Token = Token, Span = Span>, 1011 1031 { ··· 1024 1044 }) 1025 1045 } 1026 1046 1027 - fn trait_<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 1047 + fn trait_<'i, I>() -> impl SParser<'i, I, TopLevel> 1028 1048 where 1029 1049 I: ValueInput<'i, Token = Token, Span = Span>, 1030 1050 { ··· 1045 1065 }) 1046 1066 } 1047 1067 1048 - fn inherent_impl<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 1068 + fn inherent_impl<'i, I>() -> impl SParser<'i, I, TopLevel> 1049 1069 where 1050 1070 I: ValueInput<'i, Token = Token, Span = Span>, 1051 1071 { ··· 1064 1084 }) 1065 1085 } 1066 1086 1067 - fn trait_impl<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 1087 + fn trait_impl<'i, I>() -> impl SParser<'i, I, TopLevel> 1068 1088 where 1069 1089 I: ValueInput<'i, Token = Token, Span = Span>, 1070 1090 { ··· 1089 1109 ) 1090 1110 } 1091 1111 1092 - fn module<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 1112 + fn module<'i, I>() -> impl SParser<'i, I, TopLevel> 1093 1113 where 1094 1114 I: ValueInput<'i, Token = Token, Span = Span>, 1095 1115 { ··· 1101 1121 }) 1102 1122 } 1103 1123 1104 - fn use_<'i, I>() -> impl SParser<'i, I, TopLevel, Ast> 1124 + fn use_<'i, I>() -> impl SParser<'i, I, TopLevel> 1105 1125 where 1106 1126 I: ValueInput<'i, Token = Token, Span = Span>, 1107 1127 { ··· 1113 1133 }) 1114 1134 } 1115 1135 1116 - pub fn file<'i, I>() -> impl NParser<'i, I, Module, Ast> 1136 + pub fn file<'i, I>() -> impl NParser<'i, I, Module> 1117 1137 where 1118 1138 I: ValueInput<'i, Token = Token, Span = Span>, 1119 1139 { ··· 1133 1153 .collect() 1134 1154 .then_ignore(end()) 1135 1155 .or(end().to(vec![])) 1136 - .map_with(|items, extra| { 1156 + .map(|items| { 1137 1157 let mut module = Module { 1138 1158 funcs: Vec::new(), 1139 1159 consts: Vec::new(),

+1 -77

slate-frontend/src/parser/types.rs

··· 1 1 use crate::parser::ast::GenericParams; 2 - use fnv::FnvHashMap; 3 - use itempath::{path, ItemPath, ItemPathBuf}; 4 - use smol_str::SmolStr; 2 + use itempath::{path, ItemPathBuf}; 5 3 use spanner::Spanned; 6 4 use std::fmt::Write; 7 5 ··· 102 100 } 103 101 } 104 102 } 105 - 106 - pub struct StructBuilder<'i> { 107 - index: &'i mut StructIndex, 108 - generics: Vec<Spanned<SmolStr>>, 109 - fields: FnvHashMap<SmolStr, Spanned<Type>>, 110 - name: ItemPathBuf, 111 - } 112 - 113 - impl<'i> StructBuilder<'i> { 114 - pub fn field(&mut self, name: SmolStr, ty: Spanned<Type>) -> &mut Self { 115 - self.fields.insert(name, ty); 116 - self 117 - } 118 - 119 - pub fn finish(self) { 120 - let struct_ = Struct { 121 - name: self.name, 122 - generics: self.generics, 123 - fields: self.fields, 124 - }; 125 - self.index.structs.push(struct_); 126 - } 127 - } 128 - 129 - #[derive(Default, Debug, Clone)] 130 - pub struct StructIndex { 131 - structs: Vec<Struct>, 132 - } 133 - 134 - impl StructIndex { 135 - pub fn new_struct( 136 - &'_ mut self, 137 - name: ItemPathBuf, 138 - generics: Vec<Spanned<SmolStr>>, 139 - ) -> StructBuilder<'_> { 140 - StructBuilder { 141 - index: self, 142 - fields: Default::default(), 143 - generics, 144 - name, 145 - } 146 - } 147 - 148 - pub fn get(&self, name: &ItemPath) -> Option<&Struct> { 149 - self.structs.iter().find(|s| s.name == name) 150 - } 151 - } 152 - 153 - impl IntoIterator for StructIndex { 154 - type Item = Struct; 155 - 156 - type IntoIter = std::vec::IntoIter<Self::Item>; 157 - 158 - fn into_iter(self) -> Self::IntoIter { 159 - self.structs.into_iter() 160 - } 161 - } 162 - 163 - impl<'s> IntoIterator for &'s StructIndex { 164 - type Item = &'s Struct; 165 - 166 - type IntoIter = std::slice::Iter<'s, Struct>; 167 - 168 - fn into_iter(self) -> Self::IntoIter { 169 - self.structs.iter() 170 - } 171 - } 172 - 173 - #[derive(Debug, PartialEq, Eq, Clone)] 174 - pub struct Struct { 175 - pub name: ItemPathBuf, 176 - pub generics: Vec<Spanned<SmolStr>>, 177 - pub fields: FnvHashMap<SmolStr, Spanned<Type>>, 178 - }

Configure Feed

Configure Feed