Continued compiler work

main.why

@@ -4,7 +4,7 @@ struct A {
 }
 
 fn main() -> int {
-    let a: int = int::hi;
+    let a: int = 100 + 100;
     let b: int = a;
     return b;
 }

src/root/compiler/compile_evaluable.rs

@@ -6,6 +6,7 @@ use crate::root::errors::name_resolver_errors::NRErrors;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::{GlobalDefinitionTable, NameResult};
 use crate::root::parser::parse_function::parse_evaluable::{EvaluableToken, EvaluableTokens};
+use crate::root::parser::parse_function::parse_operator::get_method_name;
 use crate::root::shared::common::{FunctionID, Indirection, TypeRef};
 use crate::root::shared::common::AddressedTypeRef;
 
@@ -84,7 +85,7 @@ pub fn compile_evaluable_into(
 
             t.instantiate_from_literal(target.local_address(), literal)?
         }
-        EvaluableTokens::InfixOperator(_, _, _) => todo!(),
+        EvaluableTokens::InfixOperator(lhs, op, rhs) => todo!(),
         EvaluableTokens::PrefixOperator(_, _) => todo!(),
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called

src/root/errors/name_resolver_errors.rs

@@ -7,7 +7,7 @@ pub enum NRErrors {
     #[error("Cannot create 'impl' for an indirect type")]
     IndirectImpl,
     #[error("Cannot find the subname ({0}) of a function ({1})")]
-    FunctionSubname(String, String),
+    NoFunctionSubname(String, String),
     #[error("Cannot find method ({0}) of type ({1})")]
     CannotFindMethod(String, String),
     #[error("Two attributes found with the same name ({0})")]

src/root/parser/parse_function/parse_operator.rs

@@ -7,25 +7,34 @@ use nom_supreme::error::GenericErrorTree;
 use nom_supreme::tag::complete::tag;
 use nom_supreme::tag::TagError;
 
-const OPERATOR_MAPS: [(&str, OperatorTokens, bool); 4] = [
-    ("+", OperatorTokens::Add, false),
-    ("-", OperatorTokens::Subtract, false),
-    ("==", OperatorTokens::Equals, false),
-    ("!", OperatorTokens::Not, true),
+const OPERATOR_MAPS: [(&str, OperatorTokens, bool, &'static str); 4] = [
+    ("+", OperatorTokens::Add, false, "add"),
+    ("-", OperatorTokens::Subtract, false, "sub"),
+    ("==", OperatorTokens::Equals, false, "eq"),
+    ("!", OperatorTokens::Not, true, "not"),
 ];
 
 // TODO: Implement functionally
 pub fn is_prefix_op(operator: &OperatorTokens) -> bool {
-    for (_, op, prefix) in &OPERATOR_MAPS {
+    for (_, op, prefix, _) in &OPERATOR_MAPS {
         if operator == op {
             return *prefix;
         }
     }
     panic!()
 }
 
+pub fn get_method_name(operator: &OperatorTokens) -> &'static str {
+    for (_, op, _, name) in &OPERATOR_MAPS {
+        if operator == op {
+            return *name;
+        }
+    }
+    panic!()
+}
+
 pub fn get_priority(operator: &OperatorTokens) -> usize {
-    for (p, (_, op, _)) in OPERATOR_MAPS.iter().enumerate() {
+    for (p, (_, op, _, _)) in OPERATOR_MAPS.iter().enumerate() {
         if operator == op {
             return p;
         }
@@ -68,7 +77,7 @@ impl OperatorTokens {
 }
 
 pub fn parse_operator(s: Span) -> ParseResult<Span, OperatorToken> {
-    for (operator, token, _) in OPERATOR_MAPS {
+    for (operator, token, _, _) in OPERATOR_MAPS {
         if let Ok((s, x)) = tag::<_, _, ErrorTree>(operator)(s) {
             return Ok((
                 s,
@@ -83,7 +92,7 @@ pub fn parse_operator(s: Span) -> ParseResult<Span, OperatorToken> {
     Err(Error(GenericErrorTree::Alt(
         OPERATOR_MAPS
             .iter()
-            .map(|(t, _, _)| GenericErrorTree::from_tag(s, *t))
+            .map(|(t, _, _, _)| GenericErrorTree::from_tag(s, *t))
             .collect(),
     )))
 }