chore: rename program -> module

src/command/build.rs

@@ -45,7 +45,7 @@ pub fn build(in_file: &Path, out_file: &Path) -> Result<(), String> {
     Ok(())
 }
 
-fn build_stdlib() -> parser::node_type::Program {
+fn build_stdlib() -> parser::node_type::Module {
     let stdlib_raw =
         Lib::get("stdio.sb").expect("Standard library not found. This should not occur.");
     let stblib_str =

src/generator/c.rs

@@ -20,7 +20,7 @@ use crate::util::Either;
 pub struct CGenerator;
 
 impl Generator for CGenerator {
-    fn generate(prog: Program) -> String {
+    fn generate(prog: Module) -> String {
         let mut code = String::new();
 
         let raw_builtins =

src/generator/js.rs

@@ -20,7 +20,7 @@ use std::collections::HashMap;
 pub struct JsGenerator;
 
 impl Generator for JsGenerator {
-    fn generate(prog: Program) -> String {
+    fn generate(prog: Module) -> String {
         let mut code = String::new();
 
         let raw_builtins =

src/generator/llvm.rs

@@ -16,16 +16,16 @@
 use crate::generator::Generator;
 use crate::parser::node_type::*;
 use inkwell::context::Context;
-use inkwell::module::Module;
+use inkwell::module;
 use inkwell::types::*;
 
 pub struct LLVMGenerator<'ctx> {
     ctx: &'ctx Context,
-    module: Module<'ctx>,
+    module: module::Module<'ctx>,
 }
 
 impl<'ctx> Generator for LLVMGenerator<'ctx> {
-    fn generate(prog: Program) -> String {
+    fn generate(prog: Module) -> String {
         let ctx = Context::create();
         let module = ctx.create_module("main");
         let mut generator = LLVMGenerator { ctx: &ctx, module };

src/generator/mod.rs

@@ -26,13 +26,13 @@ mod tests;
 pub mod x86;
 
 pub trait Generator {
-    fn generate(prog: Program) -> String;
+    fn generate(prog: Module) -> String;
 }
 
 // Since we're using multiple features,
 // "unreachable" statements are okay
 #[allow(unreachable_code)]
-pub fn generate(prog: Program) -> String {
+pub fn generate(prog: Module) -> String {
     #[cfg(feature = "backend_llvm")]
     return llvm::LLVMGenerator::generate(prog);
     #[cfg(feature = "backend_c")]

src/generator/x86.rs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 use crate::generator::Generator;
-use crate::parser::node_type::{Function, Program, Statement};
+use crate::parser::node_type::{Function, Module, Statement};
 
 struct Assembly {
     asm: Vec<String>,
@@ -45,7 +45,7 @@ impl Assembly {
 pub struct X86Generator;
 
 impl Generator for X86Generator {
-    fn generate(prog: Program) -> String {
+    fn generate(prog: Module) -> String {
         Self::new().gen_program(prog).build()
     }
 }
@@ -55,9 +55,9 @@ impl X86Generator {
         X86Generator {}
     }
 
-    fn gen_program(&mut self, prog: Program) -> Assembly {
+    fn gen_program(&mut self, prog: Module) -> Assembly {
         let mut asm = Assembly::new();
-        let Program {
+        let Module {
             func,
             globals,
             structs: _,

src/parser/infer.rs

@@ -19,7 +19,7 @@ use super::node_type::*;
 ///
 /// TODO: Global symbol table is passed around randomly.
 /// This could probably be cleaned up.
-pub(super) fn infer(program: &mut Program) {
+pub(super) fn infer(program: &mut Module) {
     let table = &program.get_symbol_table();
     // TODO: Fix aweful nesting
     for func in &mut program.func {

src/parser/mod.rs

@@ -20,11 +20,11 @@ pub mod node_type;
 mod parser;
 mod rules;
 use crate::lexer::Token;
-use node_type::Program;
+use node_type::Module;
 #[cfg(test)]
 mod tests;
 
-pub fn parse(tokens: Vec<Token>, raw: Option<String>) -> Result<Program, String> {
+pub fn parse(tokens: Vec<Token>, raw: Option<String>) -> Result<Module, String> {
     let mut parser = parser::Parser::new(tokens, raw);
     parser.parse()
 }

src/parser/node_type.rs

@@ -21,14 +21,14 @@ use std::collections::HashMap;
 pub type SymbolTable = HashMap<String, Option<Type>>;
 
 #[derive(Debug)]
-pub struct Program {
+pub struct Module {
     pub func: Vec<Function>,
     pub structs: Vec<StructDef>,
     pub globals: Vec<String>,
 }
 
-impl Program {
-    pub fn merge_with(&mut self, mut other: Program) {
+impl Module {
+    pub fn merge_with(&mut self, mut other: Module) {
         self.func.append(&mut other.func);
         self.globals.append(&mut other.globals)
     }

src/parser/parser.rs

@@ -46,8 +46,8 @@ impl Parser {
         }
     }
 
-    pub fn parse(&mut self) -> Result<Program, String> {
-        let mut program = self.parse_program()?;
+    pub fn parse(&mut self) -> Result<Module, String> {
+        let mut program = self.parse_module()?;
         // infer types
         infer(&mut program);
 

src/parser/rules.rs

@@ -22,7 +22,7 @@ use std::collections::HashMap;
 use std::convert::TryFrom;
 
 impl Parser {
-    pub fn parse_program(&mut self) -> Result<Program, String> {
+    pub fn parse_module(&mut self) -> Result<Module, String> {
         let mut functions = Vec::new();
         let mut structs = Vec::new();
         let globals = Vec::new();
@@ -38,7 +38,7 @@ impl Parser {
             }
         }
 
-        Ok(Program {
+        Ok(Module {
             func: functions,
             structs,
             globals,