frontend: Emit bytecode as part of Emitter

Author: dinfuehr

dora-frontend/src/generator.rs

@@ -10,6 +10,7 @@ use self::expr::{
     gen_expr, gen_expr_bin_cmp, gen_expr_condition, gen_fatal_error, gen_intrinsic_bin,
     gen_method_bin,
 };
+use crate::program_emitter::Emitter;
 use crate::sema::{
     emit_as_bytecode_operation, new_identity_type_params, AnalysisData, CallType,
     ClassDefinitionId, ConstDefinitionId, ContextFieldId, Element, EnumDefinitionId, FctDefinition,
@@ -42,16 +43,22 @@ impl LoopLabels {
     }
 }
 
-pub fn generate_fct_id(sa: &Sema, id: FctDefinitionId) -> BytecodeFunction {
+pub fn generate_fct_id(sa: &Sema, emitter: &mut Emitter, id: FctDefinitionId) -> BytecodeFunction {
     let fct = sa.fct(id);
     let analysis = fct.analysis();
 
-    generate_fct(sa, &fct, analysis)
+    generate_fct(sa, emitter, &fct, analysis)
 }
 
-pub fn generate_fct(sa: &Sema, fct: &FctDefinition, src: &AnalysisData) -> BytecodeFunction {
+pub fn generate_fct(
+    sa: &Sema,
+    emitter: &mut Emitter,
+    fct: &FctDefinition,
+    src: &AnalysisData,
+) -> BytecodeFunction {
     let ast_bytecode_generator = AstBytecodeGen {
         sa,
+        emitter,
         type_params_len: fct.type_param_definition().type_param_count(),
         is_lambda: fct.is_lambda(),
         return_type: fct.return_type(),
@@ -70,11 +77,13 @@ pub fn generate_fct(sa: &Sema, fct: &FctDefinition, src: &AnalysisData) -> Bytec
 
 pub fn generate_global_initializer(
     sa: &Sema,
+    emitter: &mut Emitter,
     global: &GlobalDefinition,
     src: &AnalysisData,
 ) -> BytecodeFunction {
     let ast_bytecode_generator = AstBytecodeGen {
         sa,
+        emitter,
         type_params_len: 0,
         is_lambda: false,
         return_type: global.ty(),
@@ -101,6 +110,8 @@ struct EnteredContext {
 
 struct AstBytecodeGen<'a> {
     sa: &'a Sema,
+    #[allow(unused)]
+    emitter: &'a mut Emitter,
     type_params_len: usize,
     is_lambda: bool,
     return_type: SourceType,

dora-frontend/src/generator/tests.rs

@@ -3,6 +3,7 @@ use std::mem;
 
 use self::Bytecode::*;
 use crate::generator::{bty_from_ty, generate_fct_id};
+use crate::program_emitter::Emitter;
 use crate::sema::{create_tuple, Sema};
 use crate::sema::{ClassDefinitionId, FieldId, SemaFlags};
 use crate::stdlib_lookup::{lookup_fct, resolve_path};
@@ -36,7 +37,8 @@ fn sema(code: &'static str) -> Sema {
 
 fn bc(sa: &Sema, path: &str) -> (BytecodeFunction, Vec<Bytecode>) {
     let fct_id = lookup_fct(sa, path);
-    let bc_fct = generate_fct_id(sa, fct_id);
+    let mut emitter = Emitter::new();
+    let bc_fct = generate_fct_id(sa, &mut emitter, fct_id);
     let code = build(&bc_fct);
 
     (bc_fct, code)

dora-frontend/src/lib.rs

@@ -116,32 +116,6 @@ pub fn emit_ast(sa: &Sema, filter: &str) {
     }
 }
 
-pub fn generate_bytecode(sa: &Sema) {
-    for (_id, fct) in sa.fcts.iter() {
-        let bc = {
-            if !fct.has_body() {
-                continue;
-            }
-
-            let analysis = fct.analysis();
-            generator::generate_fct(sa, &*fct, analysis)
-        };
-
-        assert!(fct.bytecode.set(bc).is_ok());
-    }
-
-    for (_id, global) in sa.globals.iter() {
-        if !global.has_initial_value() {
-            continue;
-        }
-
-        let analysis = global.analysis();
-        let bc = generator::generate_global_initializer(sa, global, analysis);
-
-        assert!(global.bytecode.set(bc).is_ok());
-    }
-}
-
 pub fn emit_bytecode(prog: &Program, filter: &str) {
     for (id, fct) in prog.functions.iter().enumerate() {
         let id = FunctionId(id.try_into().expect("overflow"));

dora-frontend/src/program_emitter.rs

@@ -9,7 +9,9 @@ use dora_bytecode::{
     TypeParamBound, TypeParamData,
 };
 
-use crate::generator::{bty_from_ty, convert_trait_type};
+use crate::generator::{
+    bty_from_ty, convert_trait_type, generate_fct, generate_global_initializer,
+};
 
 use crate::sema::{
     self, AliasDefinitionId, ClassDefinition, Element, EnumDefinition, FctDefinitionId, FctParent,
@@ -21,22 +23,7 @@ use crate::sema::{
 };
 
 pub fn emit_program(sa: Sema) -> Program {
-    let mut emitter = Emitter {
-        global_initializer: HashMap::new(),
-        map_functions: HashMap::new(),
-        functions: Vec::new(),
-        globals: Vec::new(),
-        packages: Vec::new(),
-        modules: Vec::new(),
-        classes: Vec::new(),
-        structs: Vec::new(),
-        enums: Default::default(),
-        traits: Default::default(),
-        source_files: Default::default(),
-        extensions: Default::default(),
-        impls: Default::default(),
-        aliases: Default::default(),
-    };
+    let mut emitter = Emitter::new();
 
     emitter.create_packages(&sa);
     emitter.create_modules(&sa);
@@ -76,7 +63,7 @@ pub fn emit_program(sa: Sema) -> Program {
     }
 }
 
-struct Emitter {
+pub struct Emitter {
     global_initializer: HashMap<GlobalDefinitionId, FunctionId>,
     map_functions: HashMap<FctDefinitionId, FunctionId>,
     functions: Vec<FunctionData>,
@@ -94,6 +81,25 @@ struct Emitter {
 }
 
 impl Emitter {
+    pub fn new() -> Emitter {
+        Emitter {
+            global_initializer: HashMap::new(),
+            map_functions: HashMap::new(),
+            functions: Vec::new(),
+            globals: Vec::new(),
+            packages: Vec::new(),
+            modules: Vec::new(),
+            classes: Vec::new(),
+            structs: Vec::new(),
+            enums: Default::default(),
+            traits: Default::default(),
+            source_files: Default::default(),
+            extensions: Default::default(),
+            impls: Default::default(),
+            aliases: Default::default(),
+        }
+    }
+
     fn create_packages(&mut self, sa: &Sema) {
         for (_id, pkg) in sa.packages.iter() {
             let name = match pkg.name {
@@ -244,6 +250,13 @@ impl Emitter {
                 FctParent::None => FunctionKind::Function,
             };
 
+            let bc_fct = if fct.has_body() {
+                let analysis = fct.analysis();
+                Some(generate_fct(sa, self, &*fct, analysis))
+            } else {
+                None
+            };
+
             let function_id = FunctionId(self.functions.len().try_into().expect("overflow"));
             self.functions.push(FunctionData {
                 name,
@@ -267,7 +280,7 @@ impl Emitter {
                 is_force_inline: fct.is_force_inline,
                 is_never_inline: fct.is_never_inline,
                 is_trait_object_ignore: fct.is_trait_object_ignore,
-                bytecode: fct.bytecode.get().cloned(),
+                bytecode: bc_fct,
                 trait_method_impl: fct
                     .trait_method_impl
                     .get()
@@ -286,6 +299,9 @@ impl Emitter {
             let fct_id = FunctionId(self.functions.len().try_into().expect("overflow"));
             let name = sa.interner.str(global.name).to_string();
 
+            let analysis = global.analysis();
+            let bc_fct = generate_global_initializer(sa, self, global, analysis);
+
             self.functions.push(FunctionData {
                 name,
                 loc: sa.compute_loc(global.file_id, global.span),
@@ -304,7 +320,7 @@ impl Emitter {
                 is_force_inline: false,
                 is_never_inline: false,
                 is_trait_object_ignore: false,
-                bytecode: Some(global.bytecode().clone()),
+                bytecode: Some(bc_fct),
                 trait_method_impl: None,
             });
 

dora/src/driver/start.rs

@@ -141,8 +141,6 @@ fn compile_std_library(flags: &DriverFlags) -> Result<Program, ()> {
         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);
@@ -191,8 +189,6 @@ fn compile_into_program(flags: &DriverFlags, file: String) -> Result<Program, ()
         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);