frontend: Prepare for separate stdlib sem check

Author: dinfuehr

dora-frontend/src/program_parser.rs

@@ -69,8 +69,11 @@ impl<'a> ProgramParser<'a> {
     }
 
     fn add_all_packages(&mut self) {
-        self.add_stdlib_package();
-        self.add_boots_package();
+        if !self.sa.flags.is_standard_library {
+            self.add_stdlib_package();
+            self.add_boots_package();
+        }
+
         self.add_program_package();
         self.add_dependency_packages();
     }
@@ -93,7 +96,7 @@ impl<'a> ProgramParser<'a> {
     }
 
     fn get_stdlib_path(&self) -> Option<PathBuf> {
-        if let Some(file_content) = self.packages.get("stdlib") {
+        if let Some(file_content) = self.packages.get("std") {
             Some(file_content.to_path().cloned().expect("path expected"))
         } else {
             let path = std::env::current_exe().expect("illegal path");

dora-frontend/src/sema.rs

@@ -90,6 +90,7 @@ pub struct SemaFlags {
     pub packages: Vec<(String, FileContent)>,
     pub program_file: Option<FileContent>,
     pub boots: bool,
+    pub is_standard_library: bool,
 }
 
 impl SemaFlags {
@@ -103,6 +104,7 @@ impl SemaFlags {
             packages,
             program_file: Some(FileContent::Content(input.to_string())),
             boots: false,
+            is_standard_library: false,
         }
     }
 
@@ -116,6 +118,7 @@ impl SemaFlags {
             packages,
             program_file: Some(FileContent::Content(input.to_string())),
             boots: false,
+            is_standard_library: false,
         }
     }
 }

dora-language-server/src/main.rs

@@ -315,6 +315,7 @@ fn compile_project(project: ProjectConfig, sender: Sender<MainLoopTask>) {
         program_file: Some(FileContent::Path(project.main.clone())),
         packages: Vec::new(),
         boots: false,
+        is_standard_library: false,
     };
 
     let mut sa = Sema::new(sem_args);

dora/src/driver/flags.rs

@@ -113,6 +113,8 @@ pub struct DriverFlags {
     pub packages: Vec<(String, PathBuf)>,
 
     pub command: Command,
+
+    pub separate_stdlib_check: bool,
 }
 
 impl DriverFlags {
@@ -177,6 +179,8 @@ impl Default for DriverFlags {
             snapshot_on_oom: None,
 
             command: Command::Run,
+
+            separate_stdlib_check: false,
         }
     }
 }
@@ -349,6 +353,8 @@ pub fn parse_arguments() -> Result<DriverFlags, String> {
             idx += 2;
         } else if arg.starts_with("--snapshot-on-oom=") {
             flags.snapshot_on_oom = Some(argument_value(arg).into());
+        } else if arg == "--separate-stdlib-check" {
+            flags.separate_stdlib_check = true;
         } else if arg.starts_with("-") {
             return Err(format!("unknown flag {}", arg));
         } else if flags.arg_file.is_none() {
@@ -441,6 +447,7 @@ pub fn create_sema_flags(flags: &DriverFlags, program_file: PathBuf) -> SemaFlag
         program_file: Some(FileContent::Path(program_file)),
         packages,
         boots: flags.include_boots(),
+        is_standard_library: false,
     }
 }
 

dora/src/driver/start.rs

@@ -5,7 +5,7 @@ use std::path::PathBuf;
 use crate::driver::flags::{self, create_sema_flags, DriverFlags};
 use dora_bytecode::{display_fct, FunctionId, PackageId, Program};
 use dora_frontend as language;
-use dora_frontend::sema::Sema;
+use dora_frontend::sema::{FileContent, Sema, SemaFlags};
 use dora_runtime::{clear_vm, execute_on_main, set_vm, VM};
 
 pub fn start() -> i32 {
@@ -45,6 +45,12 @@ pub fn start() -> i32 {
             }
         }
     } else {
+        if flags.separate_stdlib_check {
+            if let Err(_) = compile_std_library(&flags) {
+                return 1;
+            }
+        }
+
         match compile_into_program(&flags, file.clone()) {
             Ok(result) => result,
             Err(_) => {
@@ -112,6 +118,63 @@ pub fn start() -> i32 {
     exit_code
 }
 
+fn compile_std_library(flags: &DriverFlags) -> Result<Program, ()> {
+    let path = get_stdlib_path(flags).expect("standard library not found");
+
+    let sema_flags = SemaFlags {
+        program_file: Some(FileContent::Path(path)),
+        packages: Vec::new(),
+        boots: false,
+        is_standard_library: true,
+    };
+
+    let mut sa = Sema::new(sema_flags);
+
+    let success = language::check_program(&mut sa);
+    assert_eq!(success, !sa.diag.borrow().has_errors());
+
+    if report_errors(&sa, flags.report_all_warnings) {
+        return Err(());
+    }
+
+    if let Some(ref filter) = flags.emit_ast {
+        language::emit_ast(&sa, filter);
+    }
+
+    language::generate_bytecode(&sa);
+
+    // Create a serializable data structure from bytecode and metadata.
+    // Here we drop the generated AST.
+    let prog = language::emit_program(sa);
+
+    if let Some(ref filter) = flags.emit_bytecode {
+        language::emit_bytecode(&prog, filter);
+    }
+
+    Ok(prog)
+}
+
+fn get_stdlib_path(flags: &DriverFlags) -> Option<PathBuf> {
+    for (name, path) in &flags.packages {
+        if name == "std" {
+            return Some(path.into());
+        }
+    }
+
+    let path = std::env::current_exe().expect("illegal path");
+    let path = path.as_path();
+
+    for ancestor in path.ancestors() {
+        let stdlib_path = ancestor.join("pkgs/std/std.dora");
+
+        if stdlib_path.exists() {
+            return Some(stdlib_path);
+        }
+    }
+
+    None
+}
+
 fn compile_into_program(flags: &DriverFlags, file: String) -> Result<Program, ()> {
     let sema_flags = create_sema_flags(flags, PathBuf::from(file));