sfja.skp/yapping
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add pos to stuff

Browse Source
This commit is contained in:
SimonFJ20 2024-06-10 15:49:16 +02:00
parent bded4e81b1
commit 1331ba1009
11 changed files with 574 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Cargo.lock generated
View File

@ -2,6 +2,12 @@
# It is not intended for manual editing.
version = 3
[[package]]
name = "assert_matches"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
[[package]]
name = "cfg-if"
version = "1.0.0"
@ -93,6 +99,7 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
name = "yapping"
version = "0.1.0"
dependencies = [
"assert_matches",
"pretty_assertions",
"rand",
]

1
Cargo.toml
View File

@ -6,5 +6,6 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
assert_matches = "1.5.0"
pretty_assertions = "1.4.0"
rand = "0.8.5"

163
src/checker.rs
View File

@ -1,11 +1,13 @@
use std::{rc::Rc, sync::Mutex};
use rand::random;
use crate::{
checked::{Node, NodeKind, Type},
itertewls::Itertewls,
parsed,
pos::{Error, ErrorAcc, Pos},
sym::Syms,
util::hash,
util::{hash, Itertewls},
};
pub trait IdGen {
@ -26,22 +28,25 @@ impl IdGen for RandIdGen {
pub struct Checker<FnIdGen: IdGen = RandIdGen> {
syms: Syms,
fn_id_gen: FnIdGen,
error_acc: Rc<Mutex<ErrorAcc>>,
}
impl Checker {
pub fn new() -> Self {
pub fn new(error_acc: Rc<Mutex<ErrorAcc>>) -> Self {
Self {
syms: Syms::new(),
fn_id_gen: RandIdGen::new(),
error_acc,
}
}
}
impl<FnIdGen: IdGen> Checker<FnIdGen> {
pub fn new_with_fn_id_gen() -> Self {
pub fn new_with_fn_id_gen(error_acc: Rc<Mutex<ErrorAcc>>) -> Self {
Self {
syms: Syms::new(),
fn_id_gen: FnIdGen::new(),
error_acc,
}
}
@ -56,19 +61,20 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
fn fn_scan(&mut self, ast: &[parsed::Node]) {
for node in ast {
if let parsed::Node::Fn {
let pos = node.pos.clone();
if let parsed::NodeKind::Fn {
subject,
params,
return_typ,
body: _,
} = node
} = &node.kind
{
let Ok(params) = self.fn_scan_params(params) else {
let Ok(params) = self.fn_scan_params(&params) else {
continue;
};
if let Some(_) = params.iter().map(|(id, _)| *id).find_first_duplicate() {
self.error("redefinition param");
self.error("redefinition param", pos.clone());
continue;
}
@ -80,14 +86,14 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
})
.collect::<Vec<_>>();
let parsed::Node::Id(id) = subject.as_ref() else { unreachable!() };
let parsed::NodeKind::Id(id) = subject.as_ref().kind else { unreachable!() };
if self.syms.defined_locally(*id) {
self.error("redefinition fn");
if self.syms.defined_locally(id) {
self.error("redefinition fn", pos.clone());
continue;
}
let return_typ = self.check_type(return_typ);
let return_typ = self.check_type(&return_typ);
let typ = Type::Fn {
id: self.fn_id_gen.gen(),
@ -95,7 +101,7 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
return_typ: Box::new(return_typ),
};
self.syms.define(*id, typ.clone());
self.syms.define(id, typ.clone());
}
}
}
@ -104,14 +110,14 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
params
.iter()
.map(|param| {
let parsed::Node::Param { subject, typ } = param else { unreachable!() };
let parsed::Node::Id(id) = subject.as_ref() else { unreachable!() };
let parsed::NodeKind::Param { subject, typ } = &param.kind else { unreachable!() };
let parsed::NodeKind::Id(id) = subject.as_ref().kind else { unreachable!() };
let typ = self.check_type(typ.as_ref().ok_or(())?);
Ok((
*id,
id,
self.node(
NodeKind::Param {
subject: Box::new(self.node(NodeKind::Id(*id), Type::Unit)),
subject: Box::new(self.node(NodeKind::Id(id), Type::Unit)),
typ: Some(typ),
},
Type::Unit,
@ -122,16 +128,17 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
}
fn check_expr(&mut self, node: &parsed::Node) -> Node {
match node {
parsed::Node::Error => self.node(NodeKind::Error, Type::Unit),
parsed::Node::Id(id) => {
let pos = node.pos.clone();
match &node.kind {
parsed::NodeKind::Error => self.node(NodeKind::Error, Type::Unit),
parsed::NodeKind::Id(id) => {
let Some(sym) = self.syms.get(*id) else {
self.error("undefined >~<");
self.error("undefined >~<", pos.clone());
return self.node(NodeKind::Error, Type::Error);
};
self.node(NodeKind::Id(*id), sym.typ.clone())
}
parsed::Node::Int(value) => self.node(
parsed::NodeKind::Int(value) => self.node(
NodeKind::Int(*value),
if *value > i32::MAX as i64 {
Type::U32
@ -139,13 +146,13 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
Type::I32
},
),
parsed::Node::Str(value) => self.node(NodeKind::Str(value.clone()), Type::Str),
parsed::Node::Group(expr) => {
let expr = self.check_expr(expr);
parsed::NodeKind::Str(value) => self.node(NodeKind::Str(value.clone()), Type::Str),
parsed::NodeKind::Group(expr) => {
let expr = self.check_expr(&expr);
let typ = expr.typ.clone();
self.node(NodeKind::Group(Box::new(expr)), typ)
}
parsed::Node::Block(stmts) => {
parsed::NodeKind::Block(stmts) => {
self.syms.enter_scope();
let stmts = stmts
.iter()
@ -158,8 +165,8 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
.unwrap_or(Type::Unit);
self.node(NodeKind::Block(stmts), typ)
}
parsed::Node::Call { subject, args } => {
let subject = Box::new(self.check_expr(subject));
parsed::NodeKind::Call { subject, args } => {
let subject = Box::new(self.check_expr(&subject));
let args = args
.iter()
@ -173,7 +180,7 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
return_typ,
} => {
if args.len() != params.len() {
self.error("too few/many args");
self.error("too few/many args", pos.clone());
break 'br Type::Error;
}
if args
@ -182,32 +189,32 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
.map(|(arg, param)| self.compatible(&arg.typ, &param))
.any(|is_compatible| !is_compatible)
{
self.error("incorrect args");
self.error("incorrect args", pos.clone());
break 'br Type::Error;
}
*return_typ
}
_ => {
self.error("not a function");
self.error("not a function", pos.clone());
Type::Error
}
}
};
self.node(NodeKind::Call { subject, args }, typ)
}
parsed::Node::If {
parsed::NodeKind::If {
cond,
truthy,
falsy,
} => {
let cond = Box::new(self.check_expr(cond));
let truthy = Box::new(self.check_expr(truthy));
let cond = Box::new(self.check_expr(&cond));
let truthy = Box::new(self.check_expr(&truthy));
let falsy = falsy.as_ref().map(|block| Box::new(self.check_expr(block)));
let typ = 'br: {
match falsy.as_ref().map(|block| block.typ.clone()) {
Some(falsy_typ) => {
if !self.compatible(&truthy.typ, &falsy_typ) {
self.error("incompatible types #2");
self.error("incompatible types #2", pos.clone());
break 'br Type::Error;
}
falsy_typ
@ -224,16 +231,16 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
typ,
)
}
parsed::Node::Loop { body } => {
parsed::NodeKind::Loop { body } => {
self.syms.enter_scope();
let body = Box::new(self.check_expr(body));
let body = Box::new(self.check_expr(&body));
let typ = body.typ.clone();
self.node(NodeKind::Loop { body }, typ)
}
parsed::Node::Break => self.node(NodeKind::Break, Type::Unit),
parsed::Node::Assign { subject, value } => {
let subject = Box::new(self.check_expr(subject));
let value = Box::new(self.check_expr(value));
parsed::NodeKind::Break => self.node(NodeKind::Break, Type::Unit),
parsed::NodeKind::Assign { subject, value } => {
let subject = Box::new(self.check_expr(&subject));
let value = Box::new(self.check_expr(&value));
match subject.kind {
NodeKind::Error => {
@ -241,28 +248,28 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
}
NodeKind::Id(_) => {}
_ => {
self.error("cannot assign to expr");
self.error("cannot assign to expr", pos.clone());
return self.node(NodeKind::Error, Type::Error);
}
}
let _typ = if !self.compatible(&subject.typ, &value.typ) {
self.error("incompatible types #3");
self.error("incompatible types #3", pos.clone());
Type::Error
} else {
subject.typ.clone()
};
self.node(NodeKind::Assign { subject, value }, Type::Unit)
}
parsed::Node::Let { subject, value } => {
let (subject, subject_typ) = match subject.as_ref() {
parsed::Node::Param { subject, typ } => {
parsed::NodeKind::Let { subject, value } => {
let (subject, subject_typ) = match &subject.as_ref().kind {
parsed::NodeKind::Param { subject, typ } => {
(subject, typ.as_ref().map(|typ| self.check_type(typ)))
}
_ => unreachable!(),
};
let value = Box::new(self.check_expr(value));
let value = Box::new(self.check_expr(&value));
let typ = value.typ.clone();
if subject_typ
@ -270,20 +277,20 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
.map(|subject_typ| !self.compatible(subject_typ, &typ))
.unwrap_or(false)
{
self.error("incompatible types #1");
self.error("incompatible types #1", pos.clone());
return self.node(NodeKind::Error, Type::Error);
}
let subject = match subject.as_ref() {
parsed::Node::Id(id) => {
if self.syms.defined_locally(*id) {
self.error("redefinition");
let subject = match subject.as_ref().kind {
parsed::NodeKind::Id(id) => {
if self.syms.defined_locally(id) {
self.error("redefinition", pos.clone());
return self.node(NodeKind::Error, Type::Error);
}
self.syms.define(*id, typ.clone());
self.syms.define(id, typ.clone());
Box::new(self.node(
NodeKind::Param {
subject: Box::new(self.node(NodeKind::Id(*id), Type::Unit)),
subject: Box::new(self.node(NodeKind::Id(id), Type::Unit)),
typ: Some(Type::Unit),
},
Type::Unit,
@ -294,21 +301,21 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
self.node(NodeKind::Let { subject, value }, Type::Unit)
}
parsed::Node::Fn {
parsed::NodeKind::Fn {
subject,
params,
return_typ: _,
body,
} => {
let parsed::Node::Id(id) = subject.as_ref() else { unreachable!() };
let parsed::NodeKind::Id(id) = subject.as_ref().kind else { unreachable!() };
let Some(sym) = self.syms.get(*id).cloned() else {
let Some(sym) = self.syms.get(id).cloned() else {
// rejected in fn scanner
return self.node(NodeKind::Error,Type::Error);
};
let Type::Fn { id: fn_id, params: param_typs, return_typ } = sym.typ else {
self.error("redefintion");
self.error("redefintion", pos.clone());
return self.node(NodeKind::Error,Type::Error);
};
@ -318,11 +325,11 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
.iter()
.zip(param_typs)
.map(|(param, typ)| {
let parsed::Node::Param { subject, .. } = param else { unreachable!() };
let parsed::Node::Id(id) = subject.as_ref() else { unreachable!() };
let parsed::NodeKind::Param { subject, .. } = &param.kind else { unreachable!() };
let parsed::NodeKind::Id(id) = subject.as_ref().kind else { unreachable!() };
self.node(
NodeKind::Param {
subject: Box::new(self.node(NodeKind::Id(*id), Type::Unit)),
subject: Box::new(self.node(NodeKind::Id(id), Type::Unit)),
typ: Some(typ),
},
Type::Unit,
@ -336,17 +343,17 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
self.syms.define(id, typ.as_ref().cloned().unwrap());
}
let body = Box::new(self.check_expr(body));
let body = Box::new(self.check_expr(&body));
if !self.compatible(&return_typ, &body.typ) {
self.error("return type violated");
self.error("return type violated", pos.clone());
}
self.syms.leave_scope().unwrap();
self.node(
NodeKind::Fn {
subject: Box::new(self.node(NodeKind::Id(*id), Type::Unit)),
subject: Box::new(self.node(NodeKind::Id(id), Type::Unit)),
params,
return_typ: *return_typ,
body,
@ -355,7 +362,7 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
Type::Unit,
)
}
parsed::Node::Return { value } => {
parsed::NodeKind::Return { value } => {
let value = value.as_ref().map(|value| Box::new(self.check_expr(value)));
let typ = value
.as_ref()
@ -363,17 +370,17 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
.unwrap_or(Type::Unit);
self.node(NodeKind::Return { value }, typ)
}
parsed::Node::Param { .. } => unreachable!("handle elsewhere"),
parsed::NodeKind::Param { .. } => unreachable!("handle elsewhere"),
}
}
fn check_type(&self, node: &parsed::Node) -> Type {
match node {
parsed::Node::Error => Type::Error,
parsed::Node::Id(value) => {
if *value == hash("i32") {
match node.kind {
parsed::NodeKind::Error => Type::Error,
parsed::NodeKind::Id(value) => {
if value == hash("i32") {
Type::I32
} else if *value == hash("u32") {
} else if value == hash("u32") {
Type::U32
} else {
todo!("symbol lookup idk")
@ -395,9 +402,13 @@ impl<FnIdGen: IdGen> Checker<FnIdGen> {
}
}
fn error<S: Into<String>>(&mut self, msg: S) {
fn error<S: Into<String>>(&mut self, msg: S, pos: Pos) {
let msg = msg.into();
println!("checker error: {msg}");
self.error_acc.lock().unwrap().add(Error {
kind: crate::pos::ErrorKind::CheckerError,
pos: Some(pos),
msg,
});
}
}
@ -421,7 +432,11 @@ fn test_checker() {
}
}
let check = |text| Checker::<SeqIdGen>::new_with_fn_id_gen().check(&Parser::new(text).parse());
let check = |text| {
let error_acc = Rc::new(Mutex::new(ErrorAcc::new()));
Checker::<SeqIdGen>::new_with_fn_id_gen(error_acc.clone())
.check(&Parser::new(text, error_acc).parse())
};
assert_eq!(
check("let a = 5; a;"),

29
src/itertewls.rs
View File

@ -1,29 +0,0 @@
enum Duplicate<T: std::hash::Hash> {
None(std::collections::HashMap<T, T>),
Found(T),
}
pub trait Itertewls<T>
where
Self: Iterator<Item = T> + Sized,
{
fn find_first_duplicate(self) -> Option<T>;
}
impl<I, Item> Itertewls<Item> for I
where
I: Iterator<Item = Item> + Sized,
Item: std::cmp::PartialEq + Clone,
{
fn find_first_duplicate(mut self) -> Option<Item> {
self.try_fold(Vec::new(), |mut used, item| {
if used.contains(&item) {
Err(item)
} else {
used.push(item);
Ok(used)
}
})
.err()
}
}

99
src/lexer.rs
View File

@ -1,22 +1,24 @@
use crate::{
pos::{Error, ErrorAcc, Pos},
token::{Token, TokenKind, TokenValue},
util::hash,
};
use std::{collections::HashMap, str::Chars};
use std::{collections::HashMap, rc::Rc, str::Chars, sync::Mutex};
pub struct Lexer<'a> {
text: &'a str,
chars: Chars<'a>,
current: Option<char>,
index: usize,
line: i32,
col: i32,
line: i64,
col: i64,
symbols: HashMap<u64, String>,
keywords: HashMap<String, TokenKind>,
error_acc: Rc<Mutex<ErrorAcc>>,
}
impl<'a> Lexer<'a> {
pub fn new(text: &'a str) -> Self {
pub fn new(text: &'a str, error_acc: Rc<Mutex<ErrorAcc>>) -> Self {
let mut chars = text.chars();
let current = chars.next();
Self {
@ -28,6 +30,7 @@ impl<'a> Lexer<'a> {
col: 1,
symbols: HashMap::new(),
keywords: Self::make_keywords(),
error_acc,
}
}
@ -48,6 +51,7 @@ impl<'a> Lexer<'a> {
}
fn next_token(&mut self) -> Option<Token> {
let pos = self.pos();
match self.current {
None => None,
Some(' ' | '\t' | '\n') => {
@ -66,11 +70,11 @@ impl<'a> Lexer<'a> {
}
_ => {
if let Some(kind) = self.keywords.get(&value) {
return self.token(kind.clone());
return self.token(kind.clone(), pos);
}
let id = hash(&value);
self.symbols.insert(id, value);
break self.token_with_value(TokenKind::Id, TokenValue::Id(id));
break self.token_with_value(TokenKind::Id, TokenValue::Id(id), pos);
}
}
}
@ -87,7 +91,11 @@ impl<'a> Lexer<'a> {
}
_ => {
let value = value.replace('_', "").parse::<i64>().unwrap();
break self.token_with_value(TokenKind::Int, TokenValue::Int(value));
break self.token_with_value(
TokenKind::Int,
TokenValue::Int(value),
pos,
);
}
}
}
@ -106,22 +114,25 @@ impl<'a> Lexer<'a> {
Some('0') => value.push('\0'),
Some(ch) => value.push(ch),
None => {
self.error("malformed string");
break self.token(TokenKind::Error);
self.error("malformed string", pos.clone());
break self.token(TokenKind::Error, pos);
}
}
}
Some('"') => {
self.step();
break self
.token_with_value(TokenKind::Str, TokenValue::Str(value));
break self.token_with_value(
TokenKind::Str,
TokenValue::Str(value),
pos,
);
}
Some(ch) => {
value.push(ch);
}
_ => {
self.error("malformed string");
break self.token(TokenKind::Error);
self.error("malformed string", pos.clone());
break self.token(TokenKind::Error, pos);
}
}
self.step()
@ -152,8 +163,8 @@ impl<'a> Lexer<'a> {
self.step();
}
(_, None) => {
self.error("malformed /**/ comment");
break self.token(TokenKind::Error);
self.error("malformed /**/ comment", pos.clone());
break self.token(TokenKind::Error, pos);
}
}
}
@ -166,7 +177,7 @@ impl<'a> Lexer<'a> {
match self.current {
Some('>') => {
self.step();
self.token(TokenKind::MinusLt)
self.token(TokenKind::MinusLt, pos)
}
_ => todo!(),
}
@ -174,21 +185,21 @@ impl<'a> Lexer<'a> {
Some(ch @ ('0' | '(' | ')' | '{' | '}' | ':' | ',' | ';' | '=')) => {
self.step();
match ch {
'0' => self.token_with_value(TokenKind::Int, TokenValue::Int(0)),
'(' => self.token(TokenKind::LParen),
')' => self.token(TokenKind::RParen),
'{' => self.token(TokenKind::LBrace),
'}' => self.token(TokenKind::RBrace),
':' => self.token(TokenKind::Colon),
',' => self.token(TokenKind::Comma),
';' => self.token(TokenKind::Semicolon),
'=' => self.token(TokenKind::Equal),
'0' => self.token_with_value(TokenKind::Int, TokenValue::Int(0), pos),
'(' => self.token(TokenKind::LParen, pos),
')' => self.token(TokenKind::RParen, pos),
'{' => self.token(TokenKind::LBrace, pos),
'}' => self.token(TokenKind::RBrace, pos),
':' => self.token(TokenKind::Colon, pos),
',' => self.token(TokenKind::Comma, pos),
';' => self.token(TokenKind::Semicolon, pos),
'=' => self.token(TokenKind::Equal, pos),
_ => unreachable!(),
}
}
Some(ch) => {
self.error(format!("unknown char '{ch}'"));
self.token(TokenKind::Error)
self.error(format!("unknown char '{ch}'"), pos.clone());
self.token(TokenKind::Error, pos)
}
}
}
@ -210,29 +221,33 @@ impl<'a> Lexer<'a> {
}
}
fn token(&self, kind: TokenKind) -> Option<Token> {
fn token(&self, kind: TokenKind, pos: Pos) -> Option<Token> {
Some(Token {
kind,
value: TokenValue::None,
index: self.index,
line: self.line,
col: self.col,
pos,
})
}
fn token_with_value(&self, kind: TokenKind, value: TokenValue) -> Option<Token> {
Some(Token {
kind,
value,
index: self.index,
line: self.line,
col: self.col,
})
fn token_with_value(&self, kind: TokenKind, value: TokenValue, pos: Pos) -> Option<Token> {
Some(Token { kind, value, pos })
}
fn error<S: Into<String>>(&mut self, msg: S) {
fn error<S: Into<String>>(&mut self, msg: S, pos: Pos) {
let msg = msg.into();
println!("lexer error: {msg}, line {}", self.line)
self.error_acc.lock().unwrap().add(Error {
kind: crate::pos::ErrorKind::LexerError,
pos: Some(pos),
msg,
});
}
fn pos(&self) -> Pos {
Pos {
index: self.index,
line: self.line,
col: self.col,
}
}
fn done(&self) -> bool {
@ -254,7 +269,7 @@ fn test_lexer() {
use TokenValue as TV;
let lex = |text| {
Lexer::new(text)
Lexer::new(text, Rc::new(Mutex::new(ErrorAcc::new())))
.map(|token| (token.kind, token.value))
.collect::<Vec<_>>()
};

7
src/main.rs
View File

@ -2,16 +2,15 @@
mod checked;
mod checker;
mod ir;
mod ir_compiler;
mod itertewls;
mod hir;
mod hir_compiler;
mod lexer;
mod parsed;
mod parser;
mod pos;
mod sym;
mod token;
mod util;
mod vm;
fn main() {
println!("Hello, world!");

16
src/parsed.rs
View File

@ -1,5 +1,19 @@
use crate::pos::Pos;
#[derive(Clone, PartialEq, Debug)]
pub enum Node {
pub struct Node {
pub kind: NodeKind,
pub pos: Pos,
}
impl Node {
pub fn new(kind: NodeKind, pos: Pos) -> Self {
Self { kind, pos }
}
}
#[derive(Clone, PartialEq, Debug)]
pub enum NodeKind {
Error,
Id(u64),
Int(i64),

479
src/parser.rs
View File

@ -1,21 +1,27 @@
use std::collections::HashMap;
use std::{collections::HashMap, rc::Rc, sync::Mutex};
use crate::{
lexer::Lexer,
parsed::Node,
parsed::{Node, NodeKind},
pos::{Error, ErrorAcc, Pos},
token::{Token, TokenKind, TokenValue},
};
pub struct Parser<'a> {
lexer: Lexer<'a>,
current: Option<Token>,
error_acc: Rc<Mutex<ErrorAcc>>,
}
impl<'a> Parser<'a> {
pub fn new(text: &'a str) -> Self {
let mut lexer = Lexer::new(text);
pub fn new(text: &'a str, error_acc: Rc<Mutex<ErrorAcc>>) -> Self {
let mut lexer = Lexer::new(text, error_acc.clone());
let current = lexer.next();
Self { lexer, current }
Self {
lexer,
current,
error_acc,
}
}
pub fn parse(&mut self) -> Vec<Node> {
@ -37,6 +43,7 @@ impl<'a> Parser<'a> {
}
fn parse_stmt(&mut self) -> Node {
let pos = self.pos().unwrap();
match self.curr_kind() {
Some(TokenKind::LBrace) => self.parse_block(),
Some(TokenKind::If) => self.parse_if(),
@ -47,7 +54,7 @@ impl<'a> Parser<'a> {
Some(TokenKind::Let) => self.parse_let(),
Some(TokenKind::Break) => {
self.step();
Node::Break
self.node(NodeKind::Break, pos.clone())
}
Some(TokenKind::Return) => {
self.step();
@ -55,7 +62,7 @@ impl<'a> Parser<'a> {
Some(TokenKind::Semicolon) => None,
_ => Some(Box::new(self.parse_expr())),
};
Node::Return { value }
self.node(NodeKind::Return { value }, pos.clone())
}
_ => self.parse_assign(),
};
@ -65,8 +72,8 @@ impl<'a> Parser<'a> {
stmt
}
_ => {
self.error("expected ';'");
Node::Error
self.error("expected ';'", pos.clone());
self.error_node(pos)
}
}
}
@ -74,85 +81,95 @@ impl<'a> Parser<'a> {
}
fn parse_fn(&mut self) -> Node {
let pos = self.pos().unwrap();
self.step();
if !self.curr_is(TokenKind::Id) {
self.error("expected id");
return Node::Error;
self.error("expected id", pos.clone());
return self.error_node(pos);
}
let subject = Box::new(self.parse_id());
if !self.curr_is(TokenKind::LParen) {
self.error("expected '('");
return Node::Error;
self.error("expected '('", pos.clone());
return self.error_node(pos);
}
let params = match self.parse_fn_params() {
Ok(params) => params,
Err(expr) => return expr,
};
if !self.curr_is(TokenKind::MinusLt) {
self.error("expected '->'");
return Node::Error;
self.error("expected '->'", pos.clone());
return self.error_node(pos);
}
self.step();
let return_typ = Box::new(self.parse_typ());
if !self.curr_is(TokenKind::LBrace) {
self.error("expected '{'");
return Node::Error;
self.error("expected '{'", pos.clone());
return self.error_node(pos);
}
let body = Box::new(self.parse_block());
Node::Fn {
subject,
params,
return_typ,
body,
}
self.node(
NodeKind::Fn {
subject,
params,
return_typ,
body,
},
pos,
)
}
fn parse_fn_params(&mut self) -> Result<Vec<Node>, Node> {
let pos = self.pos().unwrap();
self.step();
let mut params = Vec::new();
if !self.curr_is(TokenKind::RParen) {
if !self.curr_is(TokenKind::Id) {
self.error("expected id");
return Err(Node::Error);
self.error("expected id", pos.clone());
return Err(self.error_node(pos));
}
params.push(self.parse_param());
while let Some(TokenKind::Comma) = self.curr_kind() {
self.step();
if self.curr_is(TokenKind::RParen) {
self.error("expected ')'");
self.error("expected ')'", pos.clone());
break;
}
params.push(self.parse_param());
}
}
if !self.curr_is(TokenKind::RParen) {
self.error("expected ')'");
return Err(Node::Error);
self.error("expected ')'", pos.clone());
return Err(self.error_node(pos));
}
self.step();
Ok(params)
}
fn parse_let(&mut self) -> Node {
let pos = self.pos().unwrap();
self.step();
if !self.curr_is(TokenKind::Id) {
self.error("expected id");
return Node::Error;
self.error("expected id", pos.clone());
return self.error_node(pos);
}
let subject = self.parse_param();
if !self.curr_is(TokenKind::Equal) {
self.error("expected '='");
return Node::Error;
self.error("expected '='", pos.clone());
return self.error_node(pos);
}
self.step();
let value = self.parse_expr();
Node::Let {
subject: Box::new(subject),
value: Box::new(value),
}
self.node(
NodeKind::Let {
subject: Box::new(subject),
value: Box::new(value),
},
pos,
)
}
fn parse_param(&mut self) -> Node {
let pos = self.pos().unwrap();
let subject = Box::new(self.parse_id());
let typ = if let Some(TokenKind::Colon) = self.curr_kind() {
self.step();
@ -160,30 +177,35 @@ impl<'a> Parser<'a> {
} else {
None
};
Node::Param { subject, typ }
self.node(NodeKind::Param { subject, typ }, pos)
}
fn parse_typ(&mut self) -> Node {
let pos = self.pos().unwrap();
match self.curr_kind() {
Some(TokenKind::Id) => self.parse_id(),
_ => {
self.error("expected type");
self.error("expected type", pos.clone());
self.step();
Node::Error
self.error_node(pos)
}
}
}
fn parse_assign(&mut self) -> Node {
let pos = self.pos().unwrap();
let subject = self.parse_expr();
match self.curr_kind() {
Some(TokenKind::Equal) => {
self.step();
let value = self.parse_expr();
Node::Assign {
subject: Box::new(subject),
value: Box::new(value),
}
self.node(
NodeKind::Assign {
subject: Box::new(subject),
value: Box::new(value),
},
pos,
)
}
_ => subject,
}
@ -194,6 +216,7 @@ impl<'a> Parser<'a> {
}
fn parse_call(&mut self) -> Node {
let pos = self.pos().unwrap();
let mut subject = self.parse_value();
loop {
match self.curr_kind() {
@ -216,15 +239,18 @@ impl<'a> Parser<'a> {
match self.curr_kind() {
Some(TokenKind::RParen) => {}
_ => {
self.error("expected ')'");
return Node::Error;
self.error("expected ')'", pos.clone());
return self.error_node(pos);
}
}
self.step();
subject = Node::Call {
subject: Box::new(subject),
args,
};
subject = self.node(
NodeKind::Call {
subject: Box::new(subject),
args,
},
pos.clone(),
);
}
_ => break subject,
}
@ -232,6 +258,7 @@ impl<'a> Parser<'a> {
}
fn parse_value(&mut self) -> Node {
let pos = self.pos().unwrap();
match self.curr_kind() {
Some(TokenKind::Id) => self.parse_id(),
Some(TokenKind::Int) => self.parse_int(),
@ -241,14 +268,15 @@ impl<'a> Parser<'a> {
Some(TokenKind::If) => self.parse_if(),
Some(TokenKind::Loop) => self.parse_loop(),
_ => {
self.error("expected value");
self.error("expected value", pos.clone());
self.step();
Node::Error
self.error_node(pos)
}
}
}
fn parse_id(&mut self) -> Node {
let pos = self.pos().unwrap();
let Some(Token {
kind: TokenKind::Id,
value: TokenValue::Id(value),
@ -258,10 +286,11 @@ impl<'a> Parser<'a> {
unreachable!()
};
self.step();
Node::Id(value)
self.node(NodeKind::Id(value), pos)
}
fn parse_int(&mut self) -> Node {
let pos = self.pos().unwrap();
let Some(Token {
kind: TokenKind::Int,
value: TokenValue::Int(value),
@ -271,10 +300,11 @@ impl<'a> Parser<'a> {
unreachable!()
};
self.step();
Node::Int(value)
self.node(NodeKind::Int(value), pos)
}
fn parse_string(&mut self) -> Node {
let pos = self.pos().unwrap();
let Some(Token {
kind: TokenKind::Str,
value: TokenValue::Str(value),
@ -284,32 +314,34 @@ impl<'a> Parser<'a> {
unreachable!()
};
self.step();
Node::Str(value.clone())
self.node(NodeKind::Str(value.clone()), pos)
}
fn parse_group(&mut self) -> Node {
let pos = self.pos().unwrap();
self.step();
let expr = Box::new(self.parse_expr());
if !self.curr_is(TokenKind::RParen) {
self.error("expected ')'");
return Node::Error;
self.error("expected ')'", pos.clone());
return self.error_node(pos);
}
self.step();
Node::Group(expr)
self.node(NodeKind::Group(expr), pos)
}
fn parse_block(&mut self) -> Node {
let pos = self.pos().unwrap();
self.step();
let mut stmts = Vec::new();
loop {
match self.curr_kind() {
None => {
self.error("expected ')'");
break Node::Error;
self.error("expected ')'", pos.clone());
break self.error_node(pos);
}
Some(TokenKind::RBrace) => {
self.step();
break Node::Block(stmts);
break self.node(NodeKind::Block(stmts), pos);
}
_ => stmts.push(self.parse_stmt()),
}
@ -317,56 +349,74 @@ impl<'a> Parser<'a> {
}
fn parse_if(&mut self) -> Node {
let pos = self.pos().unwrap();
self.step();
let cond = Box::new(self.parse_expr());
if !self.curr_is(TokenKind::LBrace) {
self.error("expected '}'");
return Node::Error;
self.error("expected '}'", pos.clone());
return self.error_node(pos);
}
let truthy = Box::new(self.parse_block());
let falsy = match self.curr_kind() {
Some(TokenKind::Else) => {
self.step();
if !self.curr_is(TokenKind::LBrace) {
self.error("expected '}'");
return Node::Error;
self.error("expected '}'", pos.clone());
return self.error_node(pos);
}
Some(Box::new(self.parse_block()))
}
_ => None,
};
Node::If {
cond,
truthy,
falsy,
}
self.node(
NodeKind::If {
cond,
truthy,
falsy,
},
pos,
)
}
fn parse_loop(&mut self) -> Node {
let pos = self.pos().unwrap();
self.step();
if !self.curr_is(TokenKind::LBrace) {
self.error("expected '}'");
return Node::Error;
self.error("expected '}'", pos.clone());
return self.error_node(pos);
}
let body = Box::new(self.parse_block());
Node::Loop { body }
self.node(NodeKind::Loop { body }, pos)
}
fn error<S: Into<String>>(&mut self, msg: S) {
fn error<S: Into<String>>(&mut self, msg: S, pos: Pos) {
let msg = msg.into();
println!(
"parser error: {msg}, line {}",
self.current
.as_ref()
.map(|t| t.line.to_string())
.unwrap_or_else(|| "-".to_string())
)
self.error_acc.lock().unwrap().add(Error {
kind: crate::pos::ErrorKind::ParserError,
pos: Some(pos),
msg,
});
}
fn step(&mut self) {
self.current = self.lexer.next();
}
fn node(&self, kind: NodeKind, pos: Pos) -> Node {
Node { kind, pos }
}
fn error_node(&self, pos: Pos) -> Node {
Node {
kind: NodeKind::Error,
pos,
}
}
fn pos(&self) -> Option<Pos> {
self.current.as_ref().map(|token| token.pos.clone())
}
fn curr_is(&self, kind: TokenKind) -> bool {
self.curr_kind() == Some(kind)
}
@ -379,100 +429,223 @@ impl<'a> Parser<'a> {
#[test]
fn test_parser() {
use crate::util::hash;
use Node::*;
use assert_matches::assert_matches;
// use pretty_assertions::assert_eq;
use NodeKind::*;
let parse = |text| Parser::new(text).parse();
macro_rules! node {
($kind:pat) => {
Node { kind: $kind, .. }
};
}
let parse = |text| Parser::new(text, Rc::new(Mutex::new(ErrorAcc::new()))).parse();
#[allow(non_snake_case)]
fn B<T>(v: T) -> Box<T> {
Box::new(v)
}
assert_eq!(Parser::new("abc;").parse(), vec![Id(hash("abc"))]);
assert_eq!(Parser::new("123;").parse(), vec![Int(123)]);
assert_eq!(
Parser::new("\"hello\";").parse(),
vec![Str("hello".to_string())]
);
assert_eq!(Parser::new("0;").parse(), vec![Int(0)]);
assert_eq!(Parser::new("0;abc;").parse(), vec![Int(0), Id(hash("abc"))]);
assert_matches!(parse("abc;")[..], [node!(Id(id))] if id == hash("abc"));
assert_matches!(parse("123;")[..], [node!(Int(123))]);
assert_matches!(&parse("\"hello\";")[..], [node!(Str(v))] if *v == "hello".to_string());
assert_matches!(parse("0;")[..], [node!(Int(0))]);
assert_matches!(parse("0;abc;")[..], [node!(Int(0)), node!(Id(id))] if id == hash("abc"));
assert_eq!(
parse("add(mul(12, 34), 56);"),
vec![Call {
subject: B(Id(hash("add"))),
args: vec![
Call {
subject: B(Id(hash("mul"))),
args: vec![Int(12), Int(34)]
},
Int(56)
]
vec![Node {
kind: Call {
subject: B(Node {
kind: Id(hash("add")),
pos: Pos {
index: 0,
line: 1,
col: 1
}
}),
args: vec![
Node {
kind: Call {
subject: B(Node {
kind: Id(14581412793212634142),
pos: Pos {
index: 4,
line: 1,
col: 5
}
}),
args: vec![
Node {
kind: Int(12),
pos: Pos {
index: 8,
line: 1,
col: 9
}
},
Node {
kind: Int(34),
pos: Pos {
index: 12,
line: 1,
col: 13
}
}
]
},
pos: Pos {
index: 4,
line: 1,
col: 5
}
},
Node {
kind: Int(56),
pos: Pos {
index: 17,
line: 1,
col: 18
}
}
]
},
pos: Pos {
index: 0,
line: 1,
col: 1
}
}]
);
assert_matches!(
&parse("a = 123;")[..],
[node!(Assign {
subject,
value
})] if matches!(subject.kind, Id(id) if id == hash("a")) && matches!(value.kind, Int(123))
);
assert_matches!(parse("break;")[..], [node!(Break)]);
assert_matches!(parse("return;")[..], [node!(Return { value: None })]);
assert_eq!(
parse("a = 123;"),
vec![Assign {
subject: B(Id(hash("a"))),
value: B(Int(123))
parse("return add(1, 2);")[..],
vec![Node {
kind: Return {
value: Some(B(Node {
kind: Call {
subject: B(Node {
kind: Id(hash("add")),
pos: Pos {
index: 7,
line: 1,
col: 8
}
}),
args: vec![
Node {
kind: Int(1),
pos: Pos {
index: 11,
line: 1,
col: 12
}
},
Node {
kind: Int(2),
pos: Pos {
index: 14,
line: 1,
col: 15
}
}
]
},
pos: Pos {
index: 7,
line: 1,
col: 8
}
}))
},
pos: Pos {
index: 0,
line: 1,
col: 1
}
}]
);
assert_eq!(parse("break;"), vec![Break]);
assert_eq!(parse("return;"), vec![Return { value: None }]);
assert_eq!(
parse("return add(1, 2);"),
vec![Return {
value: Some(B(Call {
subject: B(Id(hash("add"))),
args: vec![Int(1), Int(2)]
}))
}]
assert_matches!(
&parse("a = 5;")[..],
[node!(Assign {
subject,
value
})] if matches!(subject.kind, Id(id) if id == hash("a")) && matches!(value.kind, Int(5))
);
assert_eq!(
parse("a = 5;"),
vec![Assign {
subject: B(Id(hash("a"))),
value: B(Int(5))
parse("let a = 5;")[..],
vec![Node {
kind: Let {
subject: B(Node {
kind: Param {
subject: B(Node {
kind: Id(hash("a")),
pos: Pos {
index: 4,
line: 1,
col: 5
}
}),
typ: None
},
pos: Pos {
index: 4,
line: 1,
col: 5
}
}),
value: B(Node {
kind: Int(5),
pos: Pos {
index: 8,
line: 1,
col: 9
}
})
},
pos: Pos {
index: 0,
line: 1,
col: 1
}
}]
);
assert_eq!(
parse("let a = 5;"),
vec![Let {
subject: B(Param {
subject: B(Id(hash("a"))),
typ: None
}),
value: B(Int(5))
}]
assert_matches!(
&parse("fn test() -> i32 {}")[..],
[node!(Fn {
subject,
params,
return_typ,
body
})] if subject.kind == Id(hash("test")) && *params == vec![] && return_typ.kind == Id(hash("i32")) && body.kind == Block(vec![])
);
assert_eq!(
parse("fn test() -> i32 {}"),
vec![Fn {
subject: B(Id(hash("test"))),
params: vec![],
return_typ: B(Id(hash("i32"))),
body: B(Block(vec![]))
}]
);
assert_eq!(
parse("if 0 {}"),
vec![If {
cond: B(Int(0)),
truthy: B(Block(vec![])),
assert_matches!(
&parse("if 0 {}")[..],
[node!(If {
cond,
truthy,
falsy: None
}]
})] if matches!(cond.kind, Int(0)) && truthy.kind == Block(vec![])
);
assert_eq!(
parse("if 0 {} else {}"),
vec![If {
cond: B(Int(0)),
truthy: B(Block(vec![])),
falsy: Some(B(Block(vec![]))),
}]
assert_matches!(
&parse("if 0 {} else {}")[..],
[node!(If {
cond,
truthy,
falsy: Some(falsy),
})] if matches!(cond.kind, Int(0)) && truthy.kind == Block(vec![]) && falsy.kind == Block(vec![])
);
assert_eq!(
parse("loop {}"),
vec![Loop {
body: B(Block(vec![])),
}]
assert_matches!(
&parse("loop {}")[..],
[node!(Loop {
body,
})] if body.kind == Block(vec![])
);
}

44
src/pos.rs Normal file
View File

@ -0,0 +1,44 @@
#[derive(Clone, PartialEq, Debug)]
pub struct Pos {
pub index: usize,
pub line: i64,
pub col: i64,
}
impl Pos {
pub fn new(index: usize, line: i64, col: i64) -> Self {
Self { index, line, col }
}
}
#[derive(Clone, Debug)]
pub struct Error {
pub kind: ErrorKind,
pub pos: Option<Pos>,
pub msg: String,
}
#[derive(Clone, Debug)]
pub enum ErrorKind {
LexerError,
ParserError,
CheckerError,
}
pub struct ErrorAcc {
errors: Vec<Error>,
}
impl ErrorAcc {
pub fn new() -> Self {
Self { errors: Vec::new() }
}
pub fn ok(&self) -> bool {
self.errors.is_empty()
}
pub fn add(&mut self, error: Error) {
self.errors.push(error)
}
}

6
src/token.rs
View File

@ -1,10 +1,10 @@
use crate::pos::Pos;
#[derive(Clone, PartialEq, Debug)]
pub struct Token {
pub kind: TokenKind,
pub value: TokenValue,
pub index: usize,
pub line: i32,
pub col: i32,
pub pos: Pos,
}
#[derive(Clone, PartialEq, Debug)]

29
src/util.rs
View File

@ -5,3 +5,32 @@ pub fn hash<H: Hash>(value: H) -> u64 {
value.hash(&mut hasher);
hasher.finish()
}
enum Duplicate<T: std::hash::Hash> {
None(std::collections::HashMap<T, T>),
Found(T),
}
pub trait Itertewls<T>
where
Self: Iterator<Item = T> + Sized,
{
fn find_first_duplicate(self) -> Option<T>;
}
impl<I, Item> Itertewls<Item> for I
where
I: Iterator<Item = Item> + Sized,
Item: std::cmp::PartialEq + Clone,
{
fn find_first_duplicate(mut self) -> Option<Item> {
self.try_fold(Vec::new(), |mut used, item| {
if used.contains(&item) {
Err(item)
} else {
used.push(item);
Ok(used)
}
})
.err()
}
}