Merge remote-tracking branch 'origin/codegen' into type-reordering

Author: Flippchen

README.md

@@ -4,14 +4,14 @@ A MiniJava Compiler written in Rust.
 
 ## MiniJava
 
-MiniJava is a subset of Java. It is a simple object-oriented language that supports classes, single inheritance(not 
+MiniJava is a subset of Java. It is a simple object-oriented language that supports classes, single inheritance(not
 supported in this compiler), and strong typing.
 
 ## Build
 
 ### Requirements
 
-- [Rust](https://rustup.rs/)
+-   [Rust](https://rustup.rs/)
 
 ### Build
 
@@ -22,29 +22,25 @@ cargo build --release
 ## Usage
 
 ```bash
-cargo r -r -- <input_file> <output_file>
+cargo r -r -- <input_file> [<output_file>]
 ```
 
-# Disclaimer
-This compiler was done as a student project and doesn't support many language features and may contain bugs. It is not intended to be used in production.
+## Documentation
 
-However, it was a great learning experience, and we hope it can be useful to someone else.
+A more detailed documentation on how to use the separate parts of the compiler is given in [User-Doc](./docs/User-Doc.md). A detailed documentation on how the project was done is given in [Project-Doc](./docs/Project-Doc.md).
 
-## Parsing
-Parsing is done using a [Pest grammar](https://pest.rs/).
+## Disclaimer
 
-## Type Checking
-I do not know what to write about type checking as i am clueless
+This compiler was done as a student project and doesn't support many language features and may contain bugs. It is not intended to be used in production.
 
-## Code Generation
-Code generation is done manually to generate Java Bytecode. The code generation uses two passes. 
-The first pass generates all instructions and the second one is used to convert relative jumps into absolute jumps.
+However, it was a great learning experience, and we hope it can be useful to someone else.
 
 ## Authors
-- Flippchen
-- Marion
-- mfloto
-- Nereuxofficial
-- Sander
-- Tori
-- Val
+
+-   Philipp Wolf (Flippchen)
+-   Maximilian Floto (mfloto)
+-   Marion Hinkel (MarionHinkel)
+-   Benedikt Brandmaier (Nereuxofficial)
+-   Tori Gönnheimer (ToriTheGreenOne)
+-   Sander Stella (SanderForGodot)
+-   Val Richter (ArtInLines)

docs/Project-Doc.md

@@ -1,5 +1,6 @@
 ## Supported types
-- Welche Types, Strukturen und deren Kombinationen werden unterstützt?
+
+-   Welche Types, Strukturen und deren Kombinationen werden unterstützt?
 
 ## Parser
 
@@ -28,32 +29,33 @@ Funktionsweise des Typecheckers:
 Der Typechecker iteriert über alle übergebenen Klassen und prüft auf mehrfache Klassendeklarationen. Die Felddeklarationen werden in einem neuen getypten Klassenobjekt gespeichert, in dem alle weiteren getypten Methoden und deren Statements gespeichert werden. Anschließend iteriert der Typechecker über alle Methoden und prüft auf mehrfache Methodendeklarationen und typisiert die Methodenparameter. Nachdem alle Statements typisiert wurden, wird der Rückgabetyp der Methode geprüft und die Methode im getypten Klassenobjekt gespeichert. Nach dem Überprüfen und Typisieren der Klasse wird diese in einen Vektor an getypten Klassen gespeichert. Nachdem alle Klassen getypt wurden, wird der Vektor an getypten Klassen zurückgegeben.
 
 Folgende Funktionen werden vom Typechecker übernommen:
--  Liest alle definierten Types/Strukturen
--  Typisierung aller Variablen und Ausdrücke
--  Checken von mehreren Klassen
--  Checken der Rückgabe-Typen von Methoden
--  Ersetzen von LocalOrFieldVar durch LocalVar oder FieldVar
 
+-   Liest alle definierten Types/Strukturen
+-   Typisierung aller Variablen und Ausdrücke
+-   Checken von mehreren Klassen
+-   Checken der Rückgabe-Typen von Methoden
+-   Ersetzen von LocalOrFieldVar durch LocalVar oder FieldVar
 
 Folgende Fehler werden vom Typechecker erkannt:
--  Mehrfache Deklaration einer Klasse
--  Mehrfache Deklaration einer Methode
--  Type-Mismatch bei Methodenrückgabe
--  Type-Mismatch bei Methodenaufruf
--  Type-Mismatch bei Methodenparametern
--  Type-Mismatch bei FieldDecl
--  Type-Mismatch bei Unary/Binary-Operationen
--  Mehrfache Deklaration von FieldDecl
--  Mehrfache Deklaration von LocalOrFieldVar
--  Nicht deklarierte Variable
--  Unbekannte Methode bei Methodenaufruf
--  Verwendung einer nicht deklarierten Variable
--  Panic bei TypedExpr in AST
--  Bedingung von If/While-Statement ist kein Bool
+
+-   Mehrfache Deklaration einer Klasse
+-   Mehrfache Deklaration einer Methode
+-   Type-Mismatch bei Methodenrückgabe
+-   Type-Mismatch bei Methodenaufruf
+-   Type-Mismatch bei Methodenparametern
+-   Type-Mismatch bei FieldDecl
+-   Type-Mismatch bei Unary/Binary-Operationen
+-   Mehrfache Deklaration von FieldDecl
+-   Mehrfache Deklaration von LocalOrFieldVar
+-   Nicht deklarierte Variable
+-   Unbekannte Methode bei Methodenaufruf
+-   Verwendung einer nicht deklarierten Variable
+-   Panic bei TypedExpr in AST
+-   Bedingung von If/While-Statement ist kein Bool
 
 ## Codegenerierung
 
-ByteCode-Umwandlung, Bugfixes, StackSize und viele Improvements: Val Richter
+ByteCode-Umwandlung, Bugfixes, StackSize und viele Verbesserungen: Val Richter
 
 Definition DIR(Duck Intermediate Representation), ConstantPool, LocalVarPool, Methoden zur Instruction-generierung, BugFixes, etwas ByteCode-Umwandlung und Umwandlung relativer in absolute Jumps: Marion Hinkel und Benedikt Brandmaier im Pair Programming
 
@@ -69,7 +71,7 @@ hatten häufig off-by-one Errors.
 
 Zudem musste eine StackMapTable implementiert werden, da die JVM sonst unsere Klassen nicht lädt.
 Das Troubleshooten von Testfehlern war auch sehr aufwending da oft javap gar nicht erst den Fehler im Klassencode ausgab
-und wir mit einem Hex-Editor die Klassen von Hand analysieren mussten, da es auch kein anderes Tool gab, um solche Fehler 
+und wir mit einem Hex-Editor die Klassen von Hand analysieren mussten, da es auch kein anderes Tool gab, um solche Fehler
 auszugeben und die Zeit fehlte ein Eigenes zu schreiben.
 
 Da es auch keine Dokumentation gibt, die in etwa zeigt, welcher Bytecode für welche Operationen genutzt wird, mussten wir
@@ -78,15 +80,13 @@ in die wir manuell Java Code eingeben und schauten, was für Bytecode bei versch
 wird, was sehr zeitaufwendig war.
 
 Auch sehr schwierig war die Implementation einer StackMapTable, da Java diese erwartet. Diese ist eine Tabelle, die für
-jede Instruktion die Typen der Elemente auf dem Stack in komprimiertem Format angibt. Diese Tabelle muss manuell 
+jede Instruktion die Typen der Elemente auf dem Stack in komprimiertem Format angibt. Diese Tabelle muss manuell
 erstellt werden und über die Typen aller Variablen, die in den Stack geschrieben wurden Bescheid wissen.
 
 ## Testing
 
--   Wer hat welche Arbeit beim Testing gemacht?
--   Wie funktioniert das Testing genau?
-
 Das Testen des Codegens war sehr aufwendig, er besteht aus diesen Schritten:
+
 1. Ein handgeschriebener TAST wird geladen
 2. Eine Java Klasse wird erstellt die jede Methode im TAST aufruft
 3. Die java Klasse wird mit javac kompiliert und ausgeführt, wobei die Ausgabe in einer Variable gespeichert wird
@@ -99,9 +99,6 @@ Das Testen des Codegens war sehr aufwendig, er besteht aus diesen Schritten:
 
 ## AST-Definition
 
--   Wer hat wie zur endgültigen Definition des ASTs beigetragen?
--   v.a. interessant, dass während der Arbeit der einzelnen Teams, der AST iterativ verändert wurde
-
-## Projektmanagement
+Die genaue Definition des ASTs, die verwendet wurde, ist in [AST-Klassendiagramm](./AST-Klassendiagramm.png) als UML-Diagramm dargestellt. Zusätzlich lassen sich in [hier](./Notizen%20zum%20AST.md) einige Erklärungen zum Diagramm finden.
 
--   Welche Arbeit lief von wem ins Projektmanagement?
+![Klassendiagramm](AST-Klassendiagramm.png)

docs/User-Doc.md

@@ -1,36 +1,43 @@
-TBD
-
-- Jeweils erwähnen wie man die Teile kompiliert und laufen lassen kann. Nicht vergessen: Wie sollte die Eingabe aussehen und wie sieht die Ausgabe dann aus?
-- Vielleicht sollten wir Command-Line Befehle für jeden der Teile im Binary Crate zur Verfügung stellen?
-
 ## Vorbedingungen
+
 [Rust installieren](https://rustup.rs/):
+
 ```bash
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 ```
-- [JDK 20](https://www.oracle.com/java/technologies/downloads/)(Wird in Tests für die Validierung des Codegens benötigt)
+
+-   [JDK 20](https://www.oracle.com/java/technologies/downloads/) (Wird in Tests für die Validierung des Codegens benötigt)
 
 # Ausführen
+
 Um eine .java in eine .class-datei zu kompilieren:
+
 ```bash
-cargo run -- <input_file>
+cargo r -r -- <input_file> [<output_file>]
 ```
 
 # Testen
+
 1. Projekt bauen: `cargo build`
 
 ## Parser
 
-2. Parser tests ausführen: `cargo test test_parser`
+2. Parser tests ausführen: `cargo test --lib test_parser`
+
+Spezifischen Test ausführen: `cargo test --lib <test_name>::test_parser`
+
 ## Typchecker
 
-2. Typechecker tests ausführen: `cargo test test_typechecker`
+2. Typechecker tests ausführen: `cargo test --lib test_typechecker`
 
-Spezifischen Test ausführen: `cargo test <test_name>::test_typechecker`
+Spezifischen Test ausführen: `cargo test --lib <test_name>::test_typechecker`
 
 ## Codegenerierung
 
-2. Codegenerierung tests ausführen: `cargo test test_codegen`
+2. Codegenerierung tests ausführen: `cargo test --lib test_codegen`
+
+Spezifischen Test ausführen: `cargo test --lib <test_name>::test_codegen`
 
 ## Testing
-Zur ausführung aller tests: `cargo test`
+
+Zur ausführung aller tests: `cargo test --lib`. Dabei sollte beachtet werden, dass die Tests teilweise die selben Dateien schreiben und entsprechend Probleme aufkommen können, wenn alle Tests auf einmal ausgeführt werden. Diese Probleme treten nicht auf, wenn die Teile des Compilers (Parser, Typchecker, Codegenerierung) einzeln getestet werden.

lib/src/codegen/ir.rs

@@ -256,7 +256,6 @@ impl ConstantPool {
                     result.extend_from_slice(&self.add(Constant::Utf8(r#type)).to_be_bytes());
                 }
                 Constant::FieldRef(FieldRef { class, field }) => {
-                    //TODO: Maybe this should be moved Prio2
                     result.push(9);
                     result.extend_from_slice(
                         &self
@@ -574,18 +573,6 @@ fn generate_class(class: &Class, dir: &mut DIR) -> IRClass {
     ir_class
 }
 
-// @Cleanup this function is never used
-/// If this method is used the caller has to still set a NameAndType constant and a FieldRef
-/// constant, which is technically optional if the field is not used but we're lazy
-fn generate_field(field: &FieldDecl, constant_pool: &mut ConstantPool) -> IRFieldDecl {
-    let name_index = constant_pool.add(Constant::Utf8(field.name.clone()));
-    let type_index = constant_pool.add(Constant::Utf8(format!(
-        "(){}",
-        field.field_type.clone().to_ir_string()
-    )));
-    IRFieldDecl::new(type_index, name_index)
-}
-
 /// Generates a Vector of instructions for a given method
 fn generate_method(
     method: &MethodDecl,

lib/src/codegen/stack.rs

@@ -82,12 +82,10 @@ impl StackMapTable {
         constant_pool: &mut ConstantPool,
     ) {
         while instruction_idx < code.len() {
-            // FIXME: When are locals added and how can we detect that from the instructions alone?
             match code.get(instruction_idx).unwrap() {
                 Instruction::invokespecial(idx) => {
                     bytes_idx += 3;
                     if let Some(Constant::MethodRef(m)) = constant_pool.get(*idx) {
-                        // FIXME: Somehow figure out how many parameters are popped when calling the given function
                         let pop_amount = 1;
                         let l = current_stack.operands.len();
                         current_stack.operands.splice(l - pop_amount..l, []);
@@ -124,7 +122,7 @@ impl StackMapTable {
                     bytes_idx += 1;
                     current_stack.operands.push(VerificationType::NULL)
                 }
-                Instruction::new(_) => todo!(), // requires special treatment, I think, see documentation VerificationType::UNINITIALIZED
+                Instruction::new(_) => unimplemented!(),
                 Instruction::aload_0 => {
                     bytes_idx += 1;
                     current_stack.operands.push(VerificationType::OBJECT(
@@ -477,8 +475,7 @@ pub(crate) enum VerificationType {
     INTEGER,
     NULL,
     UNINITIALIZED_THIS,
-    OBJECT(u16),        // index in constant pool
-    UNINITIALIZED(u16), // offset (see docs for specific infos)
+    OBJECT(u16), // index in constant pool
 }
 
 impl VerificationType {
@@ -494,7 +491,6 @@ impl VerificationType {
                 v.extend_from_slice(&cp_idx.to_be_bytes());
                 v
             }
-            VerificationType::UNINITIALIZED(offset) => todo!(),
         }
     }
 }

lib/src/parser/parser.rs

@@ -52,7 +52,7 @@ fn parse_class(pair: Pair<Rule>) -> Class {
                 methods,
             }
         }
-        _ => todo!(),
+        _ => unreachable!(),
     }
 }
 fn next_id(inners: &mut Pairs<Rule>) -> String {
@@ -182,7 +182,7 @@ fn parse_Stmt(pair: Pair<Rule>) -> Vec<Stmt> {
         pair.as_str()
     );
     match pair.as_rule() {
-        Rule::Stmt => parse_Stmt(pair.into_inner().next().unwrap()), //@Notice this may be very wrong !!
+        Rule::Stmt => parse_Stmt(pair.into_inner().next().unwrap()),
         Rule::WhileStmt => {
             let mut inners = pair.into_inner();
             let Expr = parse_expr(inners.next().unwrap());

lib/src/tests/mod.rs

@@ -61,7 +61,6 @@ fn normalize_str(s: std::string::String) -> std::string::String {
 
 pub fn parser_test(ast: &Class, name: &str) {
     // Call parser with java code
-    // TODO: Can only be done, once we have a parsing method that returns a Class
     let parse_res = parser::parse_programm(
         &read_to_string(File::open(format!("lib/testcases/{name}.java")).unwrap()).unwrap(),
     )
@@ -71,7 +70,6 @@ pub fn parser_test(ast: &Class, name: &str) {
 }
 
 pub fn typechecker_test(ast: &Class, tast: &Class) {
-    // TODO: Errors are just ignored for now, oops
     let mut tc = TypeChecker::new(vec![ast.clone()]).unwrap();
     let typed_classes = tc.check_and_type_program().unwrap();
     assert_eq!(typed_classes[0], *tast);
@@ -80,7 +78,6 @@ pub fn typechecker_test(ast: &Class, tast: &Class) {
 const TEST_VALS_AMOUNT: usize = 5;
 static BOOL_TEST_VALS: [&str; 4] = ["true", "false", "false", "true"];
 static CHAR_TEST_VALS: [&str; TEST_VALS_AMOUNT] = ["'c'", "'x'", "'!'", "'a'", "'f'"];
-static INT_TEST_VALS: [&str; TEST_VALS_AMOUNT] = ["5", "8", "257", "0", "69"];
 static STR_TEST_VALS: [&str; TEST_VALS_AMOUNT] = [
     "\"a\"",
     "\"test\"",
@@ -93,7 +90,7 @@ pub fn get_test_val(t: Type, i: usize) -> std::string::String {
     match t {
         Type::Bool => BOOL_TEST_VALS[xorshift().wrapping_add(i) % BOOL_TEST_VALS.len()].to_string(),
         Type::Char => CHAR_TEST_VALS[i % CHAR_TEST_VALS.len()].to_string(),
-        Type::Int => INT_TEST_VALS[i % INT_TEST_VALS.len()].to_string(),
+        Type::Int => (xorshift().wrapping_add(i) % 30).to_string(),
         Type::Null => "null".to_string(),
         Type::Void => panic!("can't create a test value for parameters of type 'void'"),
         Type::String => STR_TEST_VALS[i % STR_TEST_VALS.len()].to_string(),

lib/src/types.rs

@@ -90,13 +90,6 @@ pub enum Stmt {
 pub enum StmtExpr {
     Assign(Expr, Expr), // first the name of the variable, then the value it is being assigned to
     New(Type, Vec<Expr>), // first the class type, that should be instantiated, then the list of arguments for the constructor
-    // FIXME: This needs to be changed to represent more how the JVM handles method calls. We need a class(at least name) and a method name with the typed arguments inside it, also the return type
-    //    #2 = Methodref          #3.#17         // MethodTest.y:(I)I
-    //    #3 = Class              #18            // MethodTest
-    //    #17 = NameAndType        #19:#20        // y:(I)I
-    //    #18 = Utf8               MethodTest
-    //    #19 = Utf8               y
-    //    #20 = Utf8               (I)I
     MethodCall(Expr, String, Vec<Expr>), // first the object to which the method belongs (e.g. Expr::This), then the name of the method and lastly the list of arguments for the method call
     TypedStmtExpr(Box<StmtExpr>, Type),
 }
@@ -272,7 +265,6 @@ impl Type {
             Type::Bool => "Z",
             Type::String => "Ljava/lang/String;",
             Type::Void => "V",
-            // FIXME: Either the class has the formatting `L<class>;' or we have to add it here.
             Type::Class(name) => name,
             _ => panic!("Invalid type: {}", self),
         }