Fix struct-parsing interfering with if-parsing

main.cpp

@@ -1,7 +0,0 @@
-#include <iostream>
-
-extern "C" {
-int mainfunc();
-}
-
-int main() { std::cout << "Return value of test: " << mainfunc() << std::endl; }

reid-llvm-lib/src/compile.rs

@@ -120,6 +120,8 @@ impl CompiledModule {
             let llvm_ir = from_cstring(LLVMPrintModuleToString(self.module_ref))
                 .expect("Unable to print LLVM IR to string");
 
+            println!("{}", llvm_ir);
+
             let mut err = ErrorMessageHolder::null();
             LLVMVerifyModule(
                 self.module_ref,
@@ -127,11 +129,6 @@ impl CompiledModule {
                 err.borrow_mut(),
             );
 
-            if let Err(e) = err.into_result() {
-                println!("{}", llvm_ir);
-                panic!("{}", e);
-            }
-
             CompileOutput {
                 triple: from_cstring(triple).expect("Unable to convert triple from cstring"),
                 assembly: asm_buffer
@@ -829,6 +826,7 @@ impl InstructionHolder {
                 FCmp(pred, lhs, rhs) => {
                     let lhs = module.values.get(&lhs).unwrap();
                     let rhs_val = module.values.get(&rhs).unwrap().value_ref;
+                    dbg!(pred.as_llvm_unsorted_float());
                     LLVMBuildFCmp(
                         module.builder_ref,
                         pred.as_llvm_unsorted_float(),
@@ -1072,12 +1070,12 @@ impl CmpPredicate {
         use CmpPredicate::*;
         use LLVMRealPredicate::*;
         match self {
-            LT => LLVMRealULT,
+            LT => LLVMRealOLT,
-            LE => LLVMRealULE,
+            LE => LLVMRealOLE,
-            GT => LLVMRealUGT,
+            GT => LLVMRealOGT,
-            GE => LLVMRealUGE,
+            GE => LLVMRealOGE,
-            EQ => LLVMRealUEQ,
+            EQ => LLVMRealOEQ,
-            NE => LLVMRealUNE,
+            NE => LLVMRealONE,
         }
     }
 }

reid/src/ast/mod.rs

@@ -152,6 +152,7 @@ pub enum ReturnType {
 pub struct StructExpression {
     name: String,
     fields: Vec<(String, Expression)>,
+    range: TokenRange,
 }
 
 #[derive(Debug, Clone)]

reid/src/ast/parse.rs

@@ -110,13 +110,9 @@ impl Parse for PrimaryExpression {
                 Kind::BlockExpr(Box::new(block)),
                 stream.get_range().unwrap(),
             )
-        } else if let Ok(ifexpr) = stream.parse() {
+        } else if let Some(Token::If) = stream.peek() {
-            Expression(Kind::IfExpr(Box::new(ifexpr)), stream.get_range().unwrap())
-        } else if let (Some(Token::Identifier(_)), Some(Token::BraceOpen)) =
-            (stream.peek(), stream.peek2())
-        {
             Expression(
-                Kind::StructExpression(stream.parse()?),
+                Kind::IfExpr(Box::new(stream.parse()?)),
                 stream.get_range().unwrap(),
             )
         } else if let (Some(Token::Et), Some(Token::MutKeyword)) = (stream.peek(), stream.peek2()) {
@@ -143,19 +139,19 @@ impl Parse for PrimaryExpression {
                 Kind::UnaryOperation(unary, Box::new(stream.parse()?)),
                 stream.get_range().unwrap(),
             )
-        } else if let Some(token) = stream.next() {
+        } else if let Some(token) = stream.peek() {
             match &token {
                 Token::Identifier(v) => {
-                    if let Some(Token::BraceOpen) = stream.peek() {
+                    if let Ok(struct_expr) = stream.parse::<StructExpression>() {
-                        Expression(
+                        let range = struct_expr.range.clone();
-                            Kind::StructExpression(stream.parse()?),
+                        Expression(Kind::StructExpression(struct_expr), range)
-                            stream.get_range().unwrap(),
-                        )
                     } else {
+                        stream.next(); // Consume ident
                         Expression(Kind::VariableName(v.clone()), stream.get_range().unwrap())
                     }
                 }
                 Token::DecimalValue(v) => {
+                    stream.next(); // Consume decimal
                     if let Some(Token::Dot) = stream.peek() {
                         stream.next(); // Consume dot
                         let Some(Token::DecimalValue(fractional)) = stream.next() else {
@@ -174,24 +170,35 @@ impl Parse for PrimaryExpression {
                         )
                     }
                 }
-                Token::StringLit(v) => Expression(
+                Token::StringLit(v) => {
-                    Kind::Literal(Literal::String(v.clone())),
+                    stream.next(); // Consume
-                    stream.get_range().unwrap(),
+                    Expression(
-                ),
+                        Kind::Literal(Literal::String(v.clone())),
-                Token::True => Expression(
+                        stream.get_range().unwrap(),
-                    Kind::Literal(Literal::Bool(true)),
+                    )
-                    stream.get_range().unwrap(),
+                }
-                ),
+                Token::True => {
-                Token::False => Expression(
+                    stream.next(); // Consume
-                    Kind::Literal(Literal::Bool(false)),
+                    Expression(
-                    stream.get_range().unwrap(),
+                        Kind::Literal(Literal::Bool(true)),
-                ),
+                        stream.get_range().unwrap(),
+                    )
+                }
+                Token::False => {
+                    stream.next(); // Consume
+                    Expression(
+                        Kind::Literal(Literal::Bool(false)),
+                        stream.get_range().unwrap(),
+                    )
+                }
                 Token::ParenOpen => {
+                    stream.next(); // Consume
                     let exp = stream.parse()?;
                     stream.expect(Token::ParenClose)?;
                     exp
                 }
                 Token::BracketOpen => {
+                    stream.next(); // Consume
                     let mut expressions = Vec::new();
                     if let Ok(exp) = stream.parse() {
                         expressions.push(exp);
@@ -521,7 +528,11 @@ impl Parse for StructExpression {
 
         stream.expect(Token::BraceClose)?;
 
-        Ok(StructExpression { name, fields })
+        Ok(StructExpression {
+            name,
+            fields,
+            range: stream.get_range().unwrap(),
+        })
     }
 }
 

reid_src/array_structs.reid

@@ -20,6 +20,11 @@ fn main() -> u32 {
 
   *a.second[2] = 15;
 
+  let b = 4;
+  if value.field < b {
+    return 0;
+  }
+
 
   return value.second[2];
 }

reid_src/float.reid

@@ -3,3 +3,7 @@
 pub fn OneHalf(var1: f32) -> f32 {
   return var1 * 1.5;
 }
+
+pub fn main() -> bool {
+  return 7.5 > 5.5;
+}