Skip to content

Commit d47924a

Browse files
ZffuZffu
authored
Merge pull request #86 from Quickfall/chore/ast-operators
[chore] Handling operators in AST
2 parents 6804a21 + a9223e7 commit d47924a

24 files changed

Lines changed: 224 additions & 231 deletions

File tree

‎Cargo.lock‎

Lines changed: 0 additions & 1 deletion
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎compiler/ast/src/lib.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,3 +5,4 @@
55
pub mod tree;
66
pub mod ctx;
77
pub mod types;
8+
pub mod operators;

‎compiler/ast/src/operators.rs‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
//! Operator related utils
2+
3+
use compiler_utils::operators::{ComparingOperator, MathOperator, MathOperatorType};
4+
use diagnostics::{DiagnosticResult, builders::make_unexpected_simple_error};
5+
use lexer::token::{LexerToken, LexerTokenType};
6+
7+
pub fn parse_math_operator(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<MathOperator> {
8+
let op = match tokens[*ind].tok_type {
9+
LexerTokenType::Plus => MathOperatorType::Add,
10+
LexerTokenType::PercentSign => MathOperatorType::Modulo,
11+
LexerTokenType::Minus => MathOperatorType::Subtract,
12+
LexerTokenType::Asterisk => {
13+
if tokens[*ind + 1].tok_type == LexerTokenType::Asterisk {
14+
*ind += 1;
15+
16+
MathOperatorType::ShiftLeft
17+
} else {
18+
MathOperatorType::Multiply
19+
}
20+
}
21+
LexerTokenType::Divide => {
22+
if tokens[*ind + 1].tok_type == LexerTokenType::Divide {
23+
*ind += 1;
24+
25+
MathOperatorType::ShiftRight
26+
} else {
27+
MathOperatorType::Divide
28+
}
29+
}
30+
31+
_ => return Err(make_unexpected_simple_error(&tokens[*ind], &tokens[*ind].tok_type).into())
32+
};
33+
34+
*ind += 1;
35+
36+
let assigns = match tokens[*ind].tok_type {
37+
LexerTokenType::EqualSign => true,
38+
_ => false
39+
};
40+
41+
*ind += 1;
42+
43+
let fast = match tokens[*ind].tok_type {
44+
LexerTokenType::Tidle => true,
45+
_ => false
46+
};
47+
48+
*ind += 1;
49+
50+
return Ok(MathOperator { operator: op, assigns, fast });
51+
}
52+
53+
pub fn parse_compare_operator(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<ComparingOperator> {
54+
let eq = match tokens[*ind + 1].tok_type {
55+
LexerTokenType::EqualSign => true,
56+
_ => false
57+
};
58+
59+
let op = match tokens[*ind].tok_type {
60+
LexerTokenType::EqualSign => {
61+
tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
62+
63+
ComparingOperator::Equal
64+
},
65+
66+
LexerTokenType::ExclamationMark => {
67+
tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
68+
69+
ComparingOperator::NotEqual
70+
},
71+
72+
LexerTokenType::AngelBracketOpen => {
73+
if eq {
74+
ComparingOperator::LowerEqual
75+
} else {
76+
ComparingOperator::Lower
77+
}
78+
},
79+
80+
LexerTokenType::AngelBracketClose => {
81+
if eq {
82+
ComparingOperator::HigherEqual
83+
} else {
84+
ComparingOperator::Higher
85+
}
86+
},
87+
88+
_ => {
89+
return Err(make_unexpected_simple_error(&tokens[*ind], &tokens[*ind].tok_type).into())
90+
}
91+
};
92+
93+
return Ok(op);
94+
}

‎compiler/ast/src/tree.rs‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,8 @@
55
use std::{collections::HashMap, fmt::Display};
66

77
use compiler_typing::TypeParameterContainer;
8-
use compiler_utils::{Position, hash::{HashedString, SelfHash}};
8+
use compiler_utils::{Position, hash::{HashedString, SelfHash}, operators::{ComparingOperator, MathOperator}};
99
use diagnostics::{DiagnosticSpanOrigin, diagnostic::{Diagnostic, Span, SpanKind, SpanPosition}};
10-
use lexer::{toks::{comp::ComparingOperator, math::MathOperator}};
1110

1211
use crate::types::ASTType;
1312

@@ -39,7 +38,7 @@ pub enum ASTTreeNodeKind {
3938
OperatorBasedConditionMember { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: ComparingOperator },
4039
BooleanBasedConditionMember { val: Box<ASTTreeNode>, negate: bool },
4140

42-
MathResult { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: MathOperator, assigns: bool },
41+
MathResult { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: MathOperator },
4342

4443
VariableReference(HashedString),
4544

‎compiler/ast_parser/src/comp.rs‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
use ast::{operators::parse_compare_operator, tree::{ASTTreeNode, ASTTreeNodeKind}};
2+
use diagnostics::DiagnosticResult;
3+
use lexer::token::LexerToken;
4+
5+
use crate::value::parse_ast_value;
6+
7+
pub fn parse_ast_compare(tokens: &Vec<LexerToken>, ind: &mut usize, original: Box<ASTTreeNode>) -> DiagnosticResult<Box<ASTTreeNode>> {
8+
let operator = parse_compare_operator(tokens, ind)?;
9+
10+
let right_val = parse_ast_value(tokens, ind)?;
11+
12+
let start_pos = original.start.clone();
13+
let end_pos = right_val.end.clone();
14+
15+
return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::OperatorBasedConditionMember { lval: original, rval: right_val, operator }, start_pos, end_pos)))
16+
}

‎compiler/ast_parser/src/lib.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ pub mod types;
2020
pub mod arrays;
2121
pub mod unwraps;
2222
pub mod use_statements;
23+
pub mod comp;
2324

2425
pub fn parse_ast_ctx(tokens: &Vec<LexerToken>) -> DiagnosticResult<ParserCtx> {
2526
let mut ind = 0;

‎compiler/ast_parser/src/math.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, diagnostic::Level, errors::MATH_OPERATION_ASSIGNS};
22
use lexer::token::LexerToken;
33

4-
use ast::{tree::{ASTTreeNode, ASTTreeNodeKind}};
4+
use ast::{operators::parse_math_operator, tree::{ASTTreeNode, ASTTreeNodeKind}};
55
use crate::value::parse_ast_value;
66

77
pub fn parse_math_operation(tokens: &Vec<LexerToken>, ind: &mut usize, original: Box<ASTTreeNode>, restricts_to_assigns: bool) -> DiagnosticResult<Box<ASTTreeNode>> {
8-
let oper = tokens[*ind].expects_math_operator()?;
8+
let oper = parse_math_operator(tokens, ind)?;
99

10-
if !oper.1 && restricts_to_assigns {
10+
if !oper.assigns && restricts_to_assigns {
1111
return Err(tokens[*ind].make_simple_diagnostic(MATH_OPERATION_ASSIGNS.0, Level::Error, MATH_OPERATION_ASSIGNS.1.to_string(), None, vec![], vec!["consider assigning this to variable".to_string()], vec!["add = at the end of the operator".to_string()]).into())
1212
}
1313

@@ -18,5 +18,5 @@ pub fn parse_math_operation(tokens: &Vec<LexerToken>, ind: &mut usize, original:
1818
let start = original.start.clone();
1919
let end = right_member.end.clone();
2020

21-
return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::MathResult { lval: original, rval: right_member, operator: oper.0, assigns: oper.1 }, start, end)))
21+
return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::MathResult { lval: original, rval: right_member, operator: oper }, start, end)))
2222
}

‎compiler/ast_parser/src/types.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ pub fn parse_type_type_parameters(tokens: &Vec<LexerToken>, ind: &mut usize) ->
4747

4848
types.push(parsed_type);
4949

50-
if tokens[*ind].is_angel_bracket_close() {
50+
if tokens[*ind].tok_type == LexerTokenType::AngelBracketClose {
5151
break;
5252
}
5353

@@ -206,7 +206,7 @@ pub fn parse_type_parameters_declaration(tokens: &Vec<LexerToken>, ind: &mut usi
206206

207207
*ind += 1;
208208

209-
if tokens[*ind].is_angel_bracket_close() {
209+
if tokens[*ind].tok_type == LexerTokenType::AngelBracketClose {
210210
break;
211211
}
212212

‎compiler/ast_parser/src/value.rs‎

Lines changed: 7 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ use ast::{make_node, tree::{ASTTreeNode, ASTTreeNodeKind}};
44
use diagnostics::{DiagnosticResult, builders::{make_expected_simple_error, make_unexpected_simple_error}};
55
use lexer::token::{LexerToken, LexerTokenType};
66

7-
use crate::{arrays::parse_array_access, functions::parse_function_call, structs::val::parse_struct_initialize, unwraps::{parse_unwrap_condition, parse_unwrap_value}};
7+
use crate::{arrays::parse_array_access, comp::parse_ast_compare, functions::parse_function_call, structs::val::parse_struct_initialize, unwraps::{parse_unwrap_condition, parse_unwrap_value}};
88
use crate::literals::{parse_integer_literal, parse_string_literal};
99
use crate::math::parse_math_operation;
1010

@@ -78,7 +78,7 @@ pub fn parse_ast_value_dotacess_chain_member(tokens: &Vec<LexerToken>, ind: &mut
7878
///
7979
pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, original: DiagnosticResult<Box<ASTTreeNode>>, invoked_on_body: bool) -> DiagnosticResult<Box<ASTTreeNode>> {
8080
match &tokens[*ind].tok_type {
81-
LexerTokenType::MathOperator(_, _) => {
81+
LexerTokenType::Plus | LexerTokenType::Minus | LexerTokenType::Asterisk | LexerTokenType::Divide => {
8282
let o = &original?;
8383
let k = Box::new(ASTTreeNode::clone(o.as_ref()));
8484

@@ -92,6 +92,10 @@ pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, origina
9292
},
9393

9494
LexerTokenType::EqualSign => {
95+
if tokens[*ind + 1].tok_type == LexerTokenType::EqualSign {
96+
return parse_ast_compare(tokens, ind, original.clone()?);
97+
}
98+
9599
*ind += 1;
96100

97101
if let Ok(v) = original.as_ref() {
@@ -118,20 +122,7 @@ pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, origina
118122
return Ok(Box::new(ASTTreeNode::new(kind, start, end)));
119123
},
120124

121-
LexerTokenType::ComparingOperator(op) => {
122-
let operator = op.clone();
123-
124-
let o = &original?;
125-
let k = Box::new(ASTTreeNode::clone(o.as_ref()));
126-
127-
*ind += 1;
128-
let right_val = parse_ast_value(tokens, ind)?;
129-
130-
let start_pos = k.start.clone();
131-
let end_pos = right_val.end.clone();
132-
133-
return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::OperatorBasedConditionMember { lval: k, rval: right_val, operator }, start_pos, end_pos)));
134-
},
125+
LexerTokenType::ExclamationMark | LexerTokenType::AngelBracketOpen | LexerTokenType::AngelBracketClose => return parse_ast_compare(tokens, ind, original.clone()?),
135126

136127
_ => return original
137128
}

‎compiler/astoir_hir/src/nodes.rs‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3,9 +3,8 @@
33
use std::collections::HashMap;
44

55
use compiler_typing::{enums::{RawEnumTypeContainer}, raw::RawType, references::TypeReference, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
6-
use compiler_utils::{Position, hash::SelfHash};
6+
use compiler_utils::{Position, hash::SelfHash, operators::{ComparingOperator, MathOperator}};
77
use diagnostics::{DiagnosticSpanOrigin, builders::{make_diff_type, make_diff_type_val}, diagnostic::{Diagnostic, Span, SpanKind, SpanPosition}, unsure_panic};
8-
use lexer::toks::{comp::ComparingOperator, math::MathOperator};
98

109
use crate::{ctx::{HIRBranchedContext, HIRContext}, resolve::resolve_to_type, structs::{HIRIfBranch, StructLRUStep}};
1110

@@ -51,7 +50,7 @@ pub enum HIRNodeKind {
5150

5251
VarAssigment { variable: usize, val: Box<HIRNode> },
5352

54-
MathOperation { left: Box<HIRNode>, right: Box<HIRNode>, operation: MathOperator, assignment: bool },
53+
MathOperation { left: Box<HIRNode>, right: Box<HIRNode>, operation: MathOperator },
5554

5655
UnwrapCondition { original: Box<HIRNode>, new_type: Type, new_var: Option<usize>, unsafe_unwrap: bool },
5756
UnwrapValue { original: Box<HIRNode>, new_type: Type, unsafe_unwrap: bool },
@@ -248,7 +247,7 @@ impl HIRNode {
248247
return Some(last.clone())
249248
},
250249

251-
HIRNodeKind::MathOperation { left, right: _, operation: _, assignment: _ } => {
250+
HIRNodeKind::MathOperation { left, right: _, operation: _ } => {
252251
return left.get_node_type(context, curr_ctx)
253252
},
254253

0 commit comments

Comments
 (0)