removed todos

Author: ArtInLines

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);

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),
         }