refactor: bug fix

Author: tahadostifam

crates/cli/src/commands.rs

@@ -14,7 +14,13 @@ use resolver::{
 };
 use static_analyzer::context::AnalysisContext;
 use std::{
-    cell::RefCell, env, io::{self, Write}, path::Path, process::exit, rc::Rc, sync::{Arc, Mutex}
+    cell::RefCell,
+    env,
+    io::{self, Write},
+    path::Path,
+    process::exit,
+    rc::Rc,
+    sync::{Arc, Mutex},
 };
 use typed_ast::{ModuleID, TypedProgramTree};
 use utils::fs::{ensure_output_dir, get_directory_of_file};
@@ -64,8 +70,13 @@ fn get_program_trees(
     {
         for (_, _, module_id, typed_program_tree) in program_trees.iter() {
             {
-                let mut analyzer =
-                    AnalysisContext::new(&resolver, *module_id, typed_program_tree.clone(), entry_points.clone(), options.disable_warnings);
+                let mut analyzer = AnalysisContext::new(
+                    &resolver,
+                    *module_id,
+                    typed_program_tree.clone(),
+                    entry_points.clone(),
+                    options.disable_warnings,
+                );
                 analyzer.analyze();
                 DiagReporter::display(&analyzer.reporter);
                 if analyzer.reporter.has_errors() {
@@ -92,7 +103,10 @@ fn prepare_compilation(
     Vec<(String, ModuleFilePath, ModuleID, Rc<RefCell<TypedProgramTree>>)>,
     Rc<Resolver>,
 ) {
-    let opts = options.to_compiler_options();
+    let mut opts = options.to_compiler_options();
+    if file_path.is_some() {
+        opts.disable_modulefs_cache = true;
+    }
     let file_path = get_entry_source_code_path(options.base_path.clone(), file_path);
     let final_build_dir = get_final_build_directory_path(options.base_path.clone(), opts.build_dir.clone());
     ensure_build_dir_subs(options.base_path.clone(), final_build_dir.clone());
@@ -103,9 +117,7 @@ fn prepare_compilation(
 }
 
 pub(crate) fn command_run(mut options: CompilerOptions, file_path: Option<String>) {
-    let (mut opts, file_path, final_build_dir, program_trees, resolver_rc) =
-        prepare_compilation(&mut options, file_path);
-    opts.disable_modulefs_cache = true;
+    let (opts, file_path, final_build_dir, program_trees, resolver_rc) = prepare_compilation(&mut options, file_path);
 
     let mut temp = env::temp_dir();
     temp.push("path");
@@ -131,7 +143,6 @@ pub(crate) fn command_run(mut options: CompilerOptions, file_path: Option<String
 }
 
 pub(crate) fn command_emit_llvm(mut options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
-    options.disable_modulefs_cache = true;
     let (opts, file_path, final_build_dir, program_trees, resolver_rc) = prepare_compilation(&mut options, file_path);
 
     let output_path = output_path.unwrap_or_else(|| {
@@ -154,7 +165,6 @@ pub(crate) fn command_emit_bytecode(
     file_path: Option<String>,
     output_path: Option<String>,
 ) {
-    options.disable_modulefs_cache = true;
     let (opts, file_path, final_build_dir, program_trees, resolver_rc) = prepare_compilation(&mut options, file_path);
 
     let output_path = output_path.unwrap_or_else(|| {
@@ -177,7 +187,6 @@ pub(crate) fn command_emit_bytecode(
 }
 
 pub(crate) fn command_emit_asm(mut options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
-    options.disable_modulefs_cache = true;
     let (opts, file_path, final_build_dir, program_trees, resolver_rc) = prepare_compilation(&mut options, file_path);
 
     let output_path = output_path.unwrap_or_else(|| {
@@ -217,7 +226,6 @@ pub(crate) fn command_build(mut options: CompilerOptions, file_path: Option<Stri
 }
 
 pub(crate) fn command_object(mut options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
-    options.disable_modulefs_cache = true;
     let (opts, file_path, final_build_dir, program_trees, resolver_rc) = prepare_compilation(&mut options, file_path);
 
     let output_path = output_path.unwrap_or_else(|| {
@@ -236,7 +244,6 @@ pub(crate) fn command_object(mut options: CompilerOptions, file_path: Option<Str
 }
 
 pub(crate) fn command_dylib(mut options: CompilerOptions, file_path: Option<String>, output_path: Option<String>) {
-    options.disable_modulefs_cache = true;
     let (opts, file_path, final_build_dir, program_trees, resolver_rc) = prepare_compilation(&mut options, file_path);
 
     let output_path = output_path.unwrap_or_else(|| {

crates/codegen/src/context/context.rs

@@ -9,7 +9,7 @@ use resolver::{Resolver, moduleloader::ModuleFilePath};
 use std::{
     cell::RefCell,
     path::{Path, PathBuf},
-    process::{exit, Command},
+    process::{Command, exit},
     rc::Rc,
     sync::{Arc, Mutex},
 };
@@ -103,6 +103,13 @@ impl CodeGenContext {
             linker_command.arg("-rdynamic");
         }
 
+        linker_command.arg("-funroll-loops");
+        linker_command.arg("-flto");
+
+        if let Some(opt_level) = self.opts.opt_level {
+            linker_command.arg(format!("-O{}", opt_level));
+        }
+
         linker_command.arg("-o").arg(output_path);
         linker_command.args(object_files_str_list);
 

crates/static_analyzer/src/context.rs

@@ -178,7 +178,7 @@ impl<'a> AnalysisContext<'a> {
                 TypedStatement::BlockStatement(typed_block_statement) => {
                     self.analyze_block_statement(typed_block_statement)
                 }
-                TypedStatement::If(typed_if) => self.analyze_if_stmt(typed_if),
+                TypedStatement::If(typed_if) => self.analyze_if_stmt(block_stmt.scope_id, typed_if, None),
                 TypedStatement::Return(typed_return) => self.analyze_return(block_stmt.scope_id, typed_return),
                 TypedStatement::Break(typed_break) => {
                     self.analyze_break(typed_break);
@@ -277,9 +277,11 @@ impl<'a> AnalysisContext<'a> {
         }
     }
 
-    fn analyze_if_stmt(&mut self, typed_if: &mut TypedIf) -> FlowState {
+    fn analyze_if_stmt(&mut self, scope_id: ScopeID, typed_if: &mut TypedIf, expected_type:Option<ConcreteType>) -> FlowState {
         let consequent_state = self.analyze_block_statement(&mut typed_if.consequent);
 
+        self.analyze_typed_expr_type(Some(scope_id), &mut typed_if.condition, expected_type.clone());
+
         let alternate_state = {
             if let Some(block_stmt) = &mut typed_if.alternate {
                 self.analyze_block_statement(&mut *block_stmt)
@@ -289,7 +291,7 @@ impl<'a> AnalysisContext<'a> {
         };
 
         typed_if.branches.iter_mut().for_each(|branch| {
-            self.analyze_if_stmt(branch);
+            self.analyze_if_stmt(scope_id, branch, expected_type.clone());
         });
 
         self.merge_flow_state(consequent_state, alternate_state)

examples/fibonacci.cyr

@@ -15,6 +15,6 @@ public func fibonacci(n: int) int {
 
 func main() {
     for (#i = 0; i < 30; i++) {
-        printf("%d\n", foo(i));
+        printf("%d\n", fibonacci(i));
     }
 }

examples/main.cyr

@@ -1,13 +1,20 @@
 extern func printf(format: const char*, ...);
-extern func malloc(size: uint) void*;
-extern func free(pointer: void*);
+extern func exit(status: int);
 
-func main() {
-    #int_ptr: int* = malloc(sizeof(int));
-
-    *int_ptr = 10;
-
-    printf("value: %d\n", *int_ptr);
+inline func fibonacci(n: int) int {
+    if (n == 0) {
+        return 0;
+    }
+    else if (n == 1) {
+        return 1;
+    }
+    else {
+        return fibonacci(n - 1) + fibonacci(n - 2);
+    }
+}
 
-    free(int_ptr);
+func main() {
+    for (#i = 0; i < 40; i = i + 1) {
+        printf("%d\n", fibonacci(i));
+    }
 }

scripts/benchmark.sh

@@ -1,5 +1,3 @@
-#!/bin/bash
-
 # benchmark.sh
 # A simple script to measure the execution time of a given program.