jeff/dust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add analysis step to run function

Browse Source
This commit is contained in:
Jeff 2024-08-07 11:38:08 -04:00
parent 5d01f1caf9
commit 7328467e64
6 changed files with 224 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
dust-lang/src/abstract_tree.rs
View File

@ -1,5 +1,5 @@
use std::{ use std::{
collections::HashMap, collections::{HashMap, VecDeque},
fmt::{self, Display, Formatter}, fmt::{self, Display, Formatter},
}; };
@ -7,6 +7,11 @@ use serde::{Deserialize, Serialize};
use crate::{Identifier, ReservedIdentifier, Span, Type, Value}; use crate::{Identifier, ReservedIdentifier, Span, Type, Value};
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct AbstractSyntaxTree {
pub nodes: VecDeque<Node>,
}
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] #[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct Node { pub struct Node {
pub statement: Statement, pub statement: Statement,

71
dust-lang/src/analyzer.rs
View File

@ -1,22 +1,22 @@
use crate::{Node, Statement}; use crate::{AbstractSyntaxTree, Node, Statement};
pub fn analyze(abstract_tree: Vec<Node>) -> Result<(), AnalyzerError> { pub fn analyze(abstract_tree: &AbstractSyntaxTree) -> Result<(), AnalyzerError> {
let analyzer = Analyzer::new(abstract_tree); let analyzer = Analyzer::new(abstract_tree);
analyzer.analyze() analyzer.analyze()
} }
pub struct Analyzer { pub struct Analyzer<'a> {
abstract_tree: Vec<Node>, abstract_tree: &'a AbstractSyntaxTree,
} }
impl Analyzer { impl<'a> Analyzer<'a> {
pub fn new(abstract_tree: Vec<Node>) -> Self { pub fn new(abstract_tree: &'a AbstractSyntaxTree) -> Self {
Analyzer { abstract_tree } Analyzer { abstract_tree }
} }
pub fn analyze(&self) -> Result<(), AnalyzerError> { pub fn analyze(&self) -> Result<(), AnalyzerError> {
for node in &self.abstract_tree { for node in &self.abstract_tree.nodes {
self.analyze_node(node)?; self.analyze_node(node)?;
} }
@ -90,15 +90,18 @@ mod tests {
#[test] #[test]
fn assignment_expect_identifier() { fn assignment_expect_identifier() {
let abstract_tree = vec![Node::new( let abstract_tree = AbstractSyntaxTree {
Statement::Assign( nodes: [Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))), Statement::Assign(
Box::new(Node::new(Statement::Constant(Value::integer(2)), (1, 2))), Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))),
), Box::new(Node::new(Statement::Constant(Value::integer(2)), (1, 2))),
(0, 2), ),
)]; (0, 2),
)]
.into(),
};
let analyzer = Analyzer::new(abstract_tree); let analyzer = Analyzer::new(&abstract_tree);
assert_eq!( assert_eq!(
analyzer.analyze(), analyzer.analyze(),
@ -110,12 +113,15 @@ mod tests {
#[test] #[test]
fn unexpected_identifier_simple() { fn unexpected_identifier_simple() {
let abstract_tree = vec![Node::new( let abstract_tree = AbstractSyntaxTree {
Statement::Identifier(Identifier::new("x")), nodes: [Node::new(
(0, 1), Statement::Identifier(Identifier::new("x")),
)]; (0, 1),
)]
.into(),
};
let analyzer = Analyzer::new(abstract_tree); let analyzer = Analyzer::new(&abstract_tree);
assert_eq!( assert_eq!(
analyzer.analyze(), analyzer.analyze(),
@ -127,18 +133,21 @@ mod tests {
#[test] #[test]
fn unexpected_identifier_nested() { fn unexpected_identifier_nested() {
let abstract_tree = vec![Node::new( let abstract_tree = AbstractSyntaxTree {
Statement::Add( nodes: [Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))), Statement::Add(
Box::new(Node::new( Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))),
Statement::Identifier(Identifier::new("x")), Box::new(Node::new(
(1, 2), Statement::Identifier(Identifier::new("x")),
)), (1, 2),
), )),
(0, 1), ),
)]; (0, 1),
)]
.into(),
};
let analyzer = Analyzer::new(abstract_tree); let analyzer = Analyzer::new(&abstract_tree);
assert_eq!( assert_eq!(
analyzer.analyze(), analyzer.analyze(),

2
dust-lang/src/lib.rs
View File

@ -15,7 +15,7 @@ pub mod r#type;
pub mod value; pub mod value;
pub mod vm; pub mod vm;
pub use abstract_tree::{Node, Statement}; pub use abstract_tree::{AbstractSyntaxTree, Node, Statement};
pub use analyzer::{analyze, Analyzer, AnalyzerError}; pub use analyzer::{analyze, Analyzer, AnalyzerError};
pub use identifier::Identifier; pub use identifier::Identifier;
pub use lex::{lex, LexError, Lexer}; pub use lex::{lex, LexError, Lexer};

294
dust-lang/src/parse.rs
View File

@ -1,11 +1,8 @@
use std::collections::VecDeque; use std::collections::VecDeque;
use crate::{ use crate::{AbstractSyntaxTree, LexError, Lexer, Node, Span, Statement, Token, Value};
lex::{LexError, Lexer},
Node, Span, Statement, Token, Value,
};
pub fn parse(input: &str) -> Result<VecDeque<Node>, ParseError> { pub fn parse(input: &str) -> Result<AbstractSyntaxTree, ParseError> {
let lexer = Lexer::new(input); let lexer = Lexer::new(input);
let mut parser = Parser::new(lexer); let mut parser = Parser::new(lexer);
let mut nodes = VecDeque::new(); let mut nodes = VecDeque::new();
@ -20,7 +17,7 @@ pub fn parse(input: &str) -> Result<VecDeque<Node>, ParseError> {
} }
} }
Ok(nodes) Ok(AbstractSyntaxTree { nodes })
} }
pub struct Parser<'src> { pub struct Parser<'src> {
@ -227,7 +224,9 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new(Statement::Constant(Value::boolean(true)), (0, 4))].into()) Ok(AbstractSyntaxTree {
nodes: [Node::new(Statement::Constant(Value::boolean(true)), (0, 4))].into()
})
); );
} }
@ -237,21 +236,23 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::PropertyAccess( nodes: [Node::new(
Box::new(Node::new( Statement::PropertyAccess(
Statement::List(vec![ Box::new(Node::new(
Node::new(Statement::Constant(Value::integer(1)), (1, 2)), Statement::List(vec![
Node::new(Statement::Constant(Value::integer(2)), (4, 5)), Node::new(Statement::Constant(Value::integer(1)), (1, 2)),
Node::new(Statement::Constant(Value::integer(3)), (7, 8)), Node::new(Statement::Constant(Value::integer(2)), (4, 5)),
]), Node::new(Statement::Constant(Value::integer(3)), (7, 8)),
(0, 9) ]),
)), (0, 9)
Box::new(Node::new(Statement::Constant(Value::integer(0)), (10, 11))), )),
), Box::new(Node::new(Statement::Constant(Value::integer(0)), (10, 11))),
(0, 11), ),
)] (0, 11),
.into()) )]
.into()
})
); );
} }
@ -261,20 +262,22 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::PropertyAccess( nodes: [Node::new(
Box::new(Node::new( Statement::PropertyAccess(
Statement::Identifier(Identifier::new("a")), Box::new(Node::new(
(0, 1) Statement::Identifier(Identifier::new("a")),
)), (0, 1)
Box::new(Node::new( )),
Statement::Identifier(Identifier::new("b")), Box::new(Node::new(
(2, 3) Statement::Identifier(Identifier::new("b")),
)), (2, 3)
), )),
(0, 3), ),
)] (0, 3),
.into()) )]
.into()
})
); );
} }
@ -284,39 +287,44 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::List(vec![ nodes: [Node::new(
Node::new(Statement::Constant(Value::integer(1)), (1, 2)), Statement::List(vec![
Node::new( Node::new(Statement::Constant(Value::integer(1)), (1, 2)),
Statement::Add( Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (4, 5))), Statement::Add(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (8, 9))), Box::new(Node::new(Statement::Constant(Value::integer(1)), (4, 5))),
Box::new(Node::new(Statement::Constant(Value::integer(1)), (8, 9))),
),
(4, 9),
), ),
(4, 9), Node::new(
), Statement::Add(
Node::new( Box::new(Node::new(
Statement::Add( Statement::Constant(Value::integer(2)),
Box::new(Node::new(Statement::Constant(Value::integer(2)), (11, 12))), (11, 12)
Box::new(Node::new( )),
Statement::Multiply( Box::new(Node::new(
Box::new(Node::new( Statement::Multiply(
Statement::Constant(Value::integer(4)), Box::new(Node::new(
(16, 17) Statement::Constant(Value::integer(4)),
)), (16, 17)
Box::new(Node::new( )),
Statement::Constant(Value::integer(10)), Box::new(Node::new(
(20, 22) Statement::Constant(Value::integer(10)),
)), (20, 22)
), )),
(15, 23), ),
),), (15, 23),
),),
),
(11, 23),
), ),
(11, 23), ]),
), (0, 24),
]), )]
(0, 24), .into()
)] })
.into())
); );
} }
@ -326,14 +334,16 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::List(vec![ nodes: [Node::new(
Node::new(Statement::Constant(Value::integer(1)), (1, 2)), Statement::List(vec![
Node::new(Statement::Constant(Value::integer(2)), (4, 5)), Node::new(Statement::Constant(Value::integer(1)), (1, 2)),
]), Node::new(Statement::Constant(Value::integer(2)), (4, 5)),
(0, 6), ]),
)] (0, 6),
.into()) )]
.into()
})
); );
} }
@ -343,7 +353,9 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new(Statement::List(vec![]), (0, 2))].into()) Ok(AbstractSyntaxTree {
nodes: [Node::new(Statement::List(vec![]), (0, 2))].into()
})
); );
} }
@ -353,7 +365,9 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new(Statement::Constant(Value::float(42.0)), (0, 4))].into()) Ok(AbstractSyntaxTree {
nodes: [Node::new(Statement::Constant(Value::float(42.0)), (0, 4))].into()
})
); );
} }
@ -363,14 +377,16 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::Add( nodes: [Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))), Statement::Add(
Box::new(Node::new(Statement::Constant(Value::integer(2)), (4, 5))), Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))),
), Box::new(Node::new(Statement::Constant(Value::integer(2)), (4, 5))),
(0, 5), ),
)] (0, 5),
.into()) )]
.into()
})
); );
} }
@ -380,14 +396,16 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::Multiply( nodes: [Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))), Statement::Multiply(
Box::new(Node::new(Statement::Constant(Value::integer(2)), (4, 5))), Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))),
), Box::new(Node::new(Statement::Constant(Value::integer(2)), (4, 5))),
(0, 5), ),
)] (0, 5),
.into()) )]
.into()
})
); );
} }
@ -397,20 +415,22 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::Add( nodes: [Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))), Statement::Add(
Box::new(Node::new( Box::new(Node::new(Statement::Constant(Value::integer(1)), (0, 1))),
Statement::Multiply( Box::new(Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(2)), (4, 5))), Statement::Multiply(
Box::new(Node::new(Statement::Constant(Value::integer(3)), (8, 9))), Box::new(Node::new(Statement::Constant(Value::integer(2)), (4, 5))),
), Box::new(Node::new(Statement::Constant(Value::integer(3)), (8, 9))),
(4, 9), ),
)), (4, 9),
), )),
(0, 9), ),
)] (0, 9),
.into()) )]
.into()
})
); );
} }
@ -420,35 +440,37 @@ mod tests {
assert_eq!( assert_eq!(
parse(input), parse(input),
Ok([Node::new( Ok(AbstractSyntaxTree {
Statement::Assign( nodes: [Node::new(
Box::new(Node::new( Statement::Assign(
Statement::Identifier(Identifier::new("a")), Box::new(Node::new(
(0, 1) Statement::Identifier(Identifier::new("a")),
)), (0, 1)
Box::new(Node::new( )),
Statement::Add( Box::new(Node::new(
Box::new(Node::new(Statement::Constant(Value::integer(1)), (4, 5))), Statement::Add(
Box::new(Node::new( Box::new(Node::new(Statement::Constant(Value::integer(1)), (4, 5))),
Statement::Multiply( Box::new(Node::new(
Box::new(Node::new( Statement::Multiply(
Statement::Constant(Value::integer(2)), Box::new(Node::new(
(8, 9) Statement::Constant(Value::integer(2)),
)), (8, 9)
Box::new(Node::new( )),
Statement::Constant(Value::integer(3)), Box::new(Node::new(
(12, 13) Statement::Constant(Value::integer(3)),
)), (12, 13)
), )),
(8, 13), ),
)), (8, 13),
), )),
(4, 13), ),
)), (4, 13),
), )),
(0, 13), ),
)] (0, 13),
.into()) )]
.into()
})
); );
} }
} }

2
dust-lang/src/type.rs
View File

@ -18,7 +18,7 @@ use std::{
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::identifier::Identifier; use crate::Identifier;
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct TypeConflict { pub struct TypeConflict {

24
dust-lang/src/vm.rs
View File

@ -1,7 +1,8 @@
use std::collections::{HashMap, VecDeque}; use std::collections::HashMap;
use crate::{ use crate::{
parse, Identifier, Node, ParseError, ReservedIdentifier, Span, Statement, Value, ValueError, parse, AbstractSyntaxTree, Analyzer, AnalyzerError, Identifier, Node, ParseError,
ReservedIdentifier, Span, Statement, Value, ValueError,
}; };
pub fn run( pub fn run(
@ -9,18 +10,22 @@ pub fn run(
variables: &mut HashMap<Identifier, Value>, variables: &mut HashMap<Identifier, Value>,
) -> Result<Option<Value>, VmError> { ) -> Result<Option<Value>, VmError> {
let abstract_syntax_tree = parse(input)?; let abstract_syntax_tree = parse(input)?;
let analyzer = Analyzer::new(&abstract_syntax_tree);
analyzer.analyze()?;
let mut vm = Vm::new(abstract_syntax_tree); let mut vm = Vm::new(abstract_syntax_tree);
vm.run(variables) vm.run(variables)
} }
pub struct Vm { pub struct Vm {
statement_nodes: VecDeque<Node>, abstract_tree: AbstractSyntaxTree,
} }
impl Vm { impl Vm {
pub fn new(statement_nodes: VecDeque<Node>) -> Self { pub fn new(abstract_tree: AbstractSyntaxTree) -> Self {
Vm { statement_nodes } Self { abstract_tree }
} }
pub fn run( pub fn run(
@ -29,7 +34,7 @@ impl Vm {
) -> Result<Option<Value>, VmError> { ) -> Result<Option<Value>, VmError> {
let mut previous_value = None; let mut previous_value = None;
while let Some(node) = self.statement_nodes.pop_front() { while let Some(node) = self.abstract_tree.nodes.pop_front() {
previous_value = self.run_node(node, variables)?; previous_value = self.run_node(node, variables)?;
} }
@ -166,6 +171,7 @@ impl Vm {
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum VmError { pub enum VmError {
AnaylyzerError(AnalyzerError),
ParseError(ParseError), ParseError(ParseError),
ValueError(ValueError), ValueError(ValueError),
@ -178,6 +184,12 @@ pub enum VmError {
ExpectedValue { position: Span }, ExpectedValue { position: Span },
} }
impl From<AnalyzerError> for VmError {
fn from(error: AnalyzerError) -> Self {
Self::AnaylyzerError(error)
}
}
impl From<ParseError> for VmError { impl From<ParseError> for VmError {
fn from(error: ParseError) -> Self { fn from(error: ParseError) -> Self {
Self::ParseError(error) Self::ParseError(error)