Merge remote-tracking branch 'origin/codegen-bene' into codegen

ArtInLines · ArtInLines · commit 41a9ce5bc9d9 · 2023-07-02T11:58:46.000+02:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -38,7 +38,7 @@ jobs:
 
       - name: Run cargo test w/ -D warnings
         if: ${{ runner.os == 'Linux' }}
-        run: cargo test -- --test-threads=1
+        run: cargo test --no-fail-fast -- --test-threads=1
       - name: Run cargo doc
         if: ${{ runner.os == 'Linux' }}
         run: cargo doc --no-deps --document-private-items --all-features
diff --git a/lib/src/codegen/ir.rs b/lib/src/codegen/ir.rs
@@ -52,7 +52,6 @@ impl DIR {
             .iter()
             .flat_map(|m| m.as_bytes(&mut self.constant_pool))
             .collect();
-        println!("Constant pool: {:?}", self.constant_pool);
         // Constant Pool
         result.extend_from_slice(&self.constant_pool.count().to_be_bytes());
         result.append(&mut self.constant_pool.as_bytes());
@@ -348,7 +347,7 @@ impl LocalVarPool {
             .iter()
             .position(|n| n == name)
             .map(|i| i as u8)
-            .expect(&*format!("Local var {:?} not found in  {:?}", name, self.0))
+            .unwrap_or_else(|| panic!("Local var {:?} not found in  {:?}", name, self.0))
     }
 }
 #[derive(Debug)]
@@ -455,9 +454,7 @@ pub struct NameAndType {
 }
 
 fn get_instruction_length(istr: &Instruction) -> u16 {
-    match istr {
-        i => i.as_bytes().len() as u16,
-    }
+    istr.as_bytes().len() as u16
 }
 
 fn get_instructions_length(instructions: &[Instruction]) -> u16 {
@@ -751,7 +748,7 @@ fn generate_code_stmt(
                     ));
                 }
                 Stmt::LocalVarDecl(types, name) => {
-                    local_var_pool.add(name.clone());
+                    local_var_pool.add(name);
                     stack.inc(1);
                 }
                 Stmt::If(expr, stmt1, stmt2) => {
@@ -902,8 +899,7 @@ fn generate_code_stmt_expr(
                 }
                 StmtExpr::New(types, exprs) => {
                     // Generate bytecode for new
-                    let class_index =
-                        constant_pool.add(Constant::Class(types.to_ir_string().to_string()));
+                    let class_index = constant_pool.add(Constant::Class(types.to_ir_string()));
                     let method_index = constant_pool.add(Constant::MethodRef(MethodRef {
                         class: types.to_ir_string(),
                         method: NameAndType {
@@ -938,7 +934,7 @@ fn generate_code_stmt_expr(
                             })
                             .collect(),
                     );
-                    fn generate_name_and_type(return_type: &Type, args: &Vec<Expr>) -> String {
+                    fn generate_name_and_type(return_type: &Type, args: &[Expr]) -> String {
                         // Argument types comma seperated
                         let argument_types = args
                             .iter()
@@ -1008,7 +1004,7 @@ fn generate_code_expr(
                     stack.inc(1);
                 }
                 Expr::String(s) => {
-                    let index = constant_pool.add(Constant::String(s.to_string()));
+                    let index = constant_pool.add(Constant::String(s));
                     result.push(Instruction::ldc(index as u8));
                     stack.inc(1);
                 }
@@ -1060,7 +1056,7 @@ fn generate_code_expr(
                     let field_index = constant_pool.add(Constant::FieldRef(FieldRef {
                         class: class_name.to_string(),
                         field: NameAndType {
-                            name: name.clone(),
+                            name,
                             r#type: r#type.to_ir_string(),
                         },
                     }));
@@ -1386,16 +1382,16 @@ fn generate_code_expr(
                     let index = local_var_pool.get_index(&name);
                     match r#type {
                         Type::Int => {
-                            result.push(Instruction::iload(index as u8));
+                            result.push(Instruction::iload(index));
                         }
                         Type::Bool => {
-                            result.push(Instruction::iload(index as u8));
+                            result.push(Instruction::iload(index));
                         }
                         Type::Char => {
-                            result.push(Instruction::iload(index as u8));
+                            result.push(Instruction::iload(index));
                         }
                         Type::String => {
-                            result.push(Instruction::aload(index as u8));
+                            result.push(Instruction::aload(index));
                         }
                         _ => panic!("Unexpected type: {:?}", r#type),
                     }
@@ -1414,7 +1410,7 @@ fn generate_code_expr(
                     let index = constant_pool.add(Constant::FieldRef(FieldRef {
                         class: class_name.to_string(),
                         field: NameAndType {
-                            name: name.clone(),
+                            name,
                             r#type: r#type.to_ir_string(),
                         },
                     }));
diff --git a/lib/src/codegen/stack.rs b/lib/src/codegen/stack.rs
@@ -394,7 +394,7 @@ impl StackMapTable {
                 .to_be_bytes(),
         );
         // Attribute
-        let mut attr: Vec<u8> = self.frames.iter().map(|x| x.as_bytes()).flatten().collect();
+        let mut attr: Vec<u8> = self.frames.iter().flat_map(|x| x.as_bytes()).collect();
         // Attribute length
         // +2 because the 2 bytes for the entries length should also be included
         result.extend_from_slice(&(2 + attr.len() as u32).to_be_bytes());
@@ -405,7 +405,7 @@ impl StackMapTable {
         result
     }
 }
-
+#[allow(clippy::upper_case_acronyms)]
 #[derive(Debug)]
 pub(crate) enum StackMapFrame {
     SAME(u8),                                                          // u8 in [0, 63]
@@ -447,7 +447,7 @@ impl StackMapFrame {
                 let mut v = Vec::with_capacity(16);
                 v.push(*appended_amount);
                 v.extend_from_slice(&offset_delta.to_be_bytes());
-                v.append(&mut types.iter().map(|t| t.as_bytes()).flatten().collect());
+                v.append(&mut types.iter().flat_map(|t| t.as_bytes()).collect());
                 let v = dbg!(v);
                 v
             }
@@ -470,7 +470,7 @@ impl StackMapFrame {
         }
     }
 }
-
+#[allow(clippy::upper_case_acronyms)]
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum VerificationType {
     TOP,
diff --git a/lib/src/parser/mod.rs b/lib/src/parser/mod.rs
@@ -1,2 +1,3 @@
+#[allow(clippy::module_inception)]
 mod parser;
 pub use parser::*;
diff --git a/lib/src/parser/parser.rs b/lib/src/parser/parser.rs
@@ -10,11 +10,12 @@ use pest::error::Error;
 use pest::iterators::{Pair, Pairs};
 use pest::Parser;
 use pest_derive::Parser;
+use tracing::debug;
 
 #[derive(Parser)]
 #[grammar = "../lib/src/parser/JavaGrammar.pest"]
 struct JavaParser;
-
+#[allow(clippy::result_large_err)]
 pub fn parse_programm(file: &str) -> Result<Vec<Class>, Error<Rule>> {
     let prg: Pair<Rule> = JavaParser::parse(Rule::Program, file)?.next().unwrap();
 
@@ -70,7 +71,7 @@ fn parse_method(pair: Pair<Rule>) -> MethodDecl {
             let method_name = next_id(&mut inners);
             let mut params = vec![];
             let mut body = None;
-            while let Some(p) = inners.next() {
+            for p in inners {
                 match p.as_rule() {
                     Rule::ParamDeclList => {
                         let mut inner_param = p.into_inner();
@@ -112,7 +113,7 @@ fn parse_BlockStmt(pair: Pair<Rule>) -> Vec<Stmt> {
         pair.as_rule(),
         pair.as_str()
     );*/
-    let rule = pair.as_rule().clone();
+    let rule = pair.as_rule();
     let mut inner = pair.into_inner();
     match rule {
         Rule::BlockStmt => {
@@ -175,11 +176,11 @@ fn parse_BlockStmt(pair: Pair<Rule>) -> Vec<Stmt> {
     }
 }
 fn parse_Stmt(pair: Pair<Rule>) -> Vec<Stmt> {
-    /* println!(
+    debug!(
         "parse_Stmt: rule = {:?}, str = {}",
         pair.as_rule(),
         pair.as_str()
-    );*/
+    );
     match pair.as_rule() {
         Rule::Stmt => parse_Stmt(pair.into_inner().next().unwrap()), //@Notice this may be very wrong !!
         Rule::WhileStmt => {
@@ -246,12 +247,12 @@ fn parse_Stmt(pair: Pair<Rule>) -> Vec<Stmt> {
 }
 
 fn parse_StmtExpr(pair: Pair<Rule>) -> StmtExpr {
-    /*println!(
+    debug!(
         "parse_StmtExpr: rule = {:?}, str = {}",
         pair.as_rule(),
         pair.as_str()
-    );*/
-    let rule = pair.as_rule().clone();
+    );
+    let rule = pair.as_rule();
     match rule {
         Rule::AssignExpr => {
             let mut inners = pair.into_inner();
@@ -339,7 +340,7 @@ fn parse_field_var_decl_list(jtype: Type, pair: Pair<Rule>) -> Vec<FieldDecl> {
     let mut inners = pair.into_inner();
     let mut var_decl = inners.next().unwrap().into_inner();
     let name = next_id(&mut var_decl);
-    let val = var_decl.next().and_then(|expr| Some(parse_expr(expr)));
+    let val = var_decl.next().map(parse_expr);
     let mut out = vec![FieldDecl {
         field_type: jtype.clone(),
         name,
@@ -348,7 +349,7 @@ fn parse_field_var_decl_list(jtype: Type, pair: Pair<Rule>) -> Vec<FieldDecl> {
     if let Some(p) = inners.next() {
         out.append(&mut parse_field_var_decl_list(jtype, p));
     }
-    return out;
+    out
 }
 
 fn parse_Type(pair: Pair<Rule>) -> Type {
@@ -393,7 +394,7 @@ fn parse_expr(pair: Pair<Rule>) -> Expr {
                     unreachable!()
                 }
             };
-            while let Some(p) = pairs.next() {
+            for p in pairs {
                 assert_eq!(p.as_rule(), Rule::Identifier);
                 obj = Expr::InstVar(Box::new(obj), p.as_str().trim().to_string());
             }
diff --git a/lib/src/tests/tast_to_ast.rs b/lib/src/tests/tast_to_ast.rs
@@ -3,16 +3,13 @@ use super::*;
 pub fn stmt_tast_to_ast(stmt: &Stmt) -> Stmt {
     match stmt {
         Stmt::TypedStmt(x, _typ) => stmt_tast_to_ast(x),
-        Stmt::Block(stmts) => Block(stmts.iter().map(|x| stmt_tast_to_ast(x)).collect()),
+        Stmt::Block(stmts) => Block(stmts.iter().map(stmt_tast_to_ast).collect()),
         Stmt::Return(expr) => Return(expr_tast_to_ast(expr)),
         Stmt::While(cond, body) => While(expr_tast_to_ast(cond), Box::new(stmt_tast_to_ast(body))),
         Stmt::If(cond, body, elze) => If(
             expr_tast_to_ast(cond),
             Box::new(stmt_tast_to_ast(body)),
-            match elze {
-                Some(x) => Some(Box::new(stmt_tast_to_ast(x))),
-                None => None,
-            },
+            elze.as_ref().map(|x| Box::new(stmt_tast_to_ast(x))),
         ),
         Stmt::StmtExprStmt(stmt_expr) => StmtExprStmt(stmt_expr_tast_to_ast(stmt_expr)),
         _ => stmt.clone(),
@@ -22,14 +19,13 @@ pub fn stmt_tast_to_ast(stmt: &Stmt) -> Stmt {
 pub fn stmt_expr_tast_to_ast(stmt_expr: &StmtExpr) -> StmtExpr {
     match stmt_expr {
         StmtExpr::Assign(var, val) => Assign(expr_tast_to_ast(var), expr_tast_to_ast(val)),
-        StmtExpr::New(typ, params) => New(
-            typ.clone(),
-            params.iter().map(|x| expr_tast_to_ast(x)).collect(),
-        ),
+        StmtExpr::New(typ, params) => {
+            New(typ.clone(), params.iter().map(expr_tast_to_ast).collect())
+        }
         StmtExpr::MethodCall(obj, method, params) => MethodCall(
             expr_tast_to_ast(obj),
             method.clone(),
-            params.iter().map(|x| expr_tast_to_ast(x)).collect(),
+            params.iter().map(expr_tast_to_ast).collect(),
         ),
         StmtExpr::TypedStmtExpr(x, _typ) => stmt_expr_tast_to_ast(x),
     }
@@ -61,7 +57,7 @@ pub fn tast_to_ast(class: &Class) -> Class {
             .map(|field| FieldDecl {
                 field_type: field.field_type.clone(),
                 name: field.name.clone(),
-                val: field.val.clone().and_then(|x| Some(expr_tast_to_ast(&x))),
+                val: field.val.clone().map(|x| expr_tast_to_ast(&x)),
             })
             .collect(),
         methods: class
diff --git a/lib/src/tests/to_java.rs b/lib/src/tests/to_java.rs
@@ -22,10 +22,10 @@ pub fn class_to_java(class: &Class) -> String {
     let mut s: String = format!("class {} ", class.name);
     s += "{\n";
     for field in &class.fields {
-        s = format!("{}{}", s, field_to_java(&field));
+        s = format!("{}{}", s, field_to_java(field));
     }
     for method in &class.methods {
-        s = format!("{}{}", s, method_to_java(&method));
+        s = format!("{}{}", s, method_to_java(method));
     }
     s += "}\n";
     s
@@ -62,7 +62,7 @@ pub fn stmt_to_java(stmt: &Stmt, indent: u8) -> String {
             "{}{{\n{}\n{}}}",
             get_indents(indent - 1),
             stmts
-                .into_iter()
+                .iter()
                 .map(|stmt| stmt_to_java(stmt, indent))
                 .fold("".to_string(), |acc, s| acc + &s),
             get_indents(indent - 1)
@@ -97,8 +97,8 @@ pub fn stmt_to_java(stmt: &Stmt, indent: u8) -> String {
 
 pub fn params_to_java(params: &Vec<Expr>) -> String {
     params
-        .into_iter()
-        .map(|expr| expr_to_java(expr))
+        .iter()
+        .map(expr_to_java)
         .reduce(|acc, s| format!("{}, {}", acc, s))
         .unwrap_or(String::new())
 }
diff --git a/lib/src/typechecker/mod.rs b/lib/src/typechecker/mod.rs
@@ -1 +1,2 @@
+#[allow(clippy::module_inception)]
 pub mod typechecker;
diff --git a/lib/src/typechecker/typechecker.rs b/lib/src/typechecker/typechecker.rs
diff --git a/src/main.rs b/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -394,7 +394,7 @@ impl StackMapTable {`
`394`	`394`	`.to_be_bytes(),`
`395`	`395`	`);`
`396`	`396`	`// Attribute`
`397`		`- let mut attr: Vec<u8> = self.frames.iter().map(\|x\| x.as_bytes()).flatten().collect();`
	`397`	`+ let mut attr: Vec<u8> = self.frames.iter().flat_map(\|x\| x.as_bytes()).collect();`
`398`	`398`	`// Attribute length`
`399`	`399`	`// +2 because the 2 bytes for the entries length should also be included`
`400`	`400`	`result.extend_from_slice(&(2 + attr.len() as u32).to_be_bytes());`
`@@ -405,7 +405,7 @@ impl StackMapTable {`
`405`	`405`	`result`
`406`	`406`	`}`
`407`	`407`	`}`
`408`		`-`
	`408`	`+#[allow(clippy::upper_case_acronyms)]`
`409`	`409`	`#[derive(Debug)]`
`410`	`410`	`pub(crate) enum StackMapFrame {`
`411`	`411`	`SAME(u8), // u8 in [0, 63]`
`@@ -447,7 +447,7 @@ impl StackMapFrame {`
`447`	`447`	`let mut v = Vec::with_capacity(16);`
`448`	`448`	`v.push(*appended_amount);`
`449`	`449`	`v.extend_from_slice(&offset_delta.to_be_bytes());`
`450`		`- v.append(&mut types.iter().map(\|t\| t.as_bytes()).flatten().collect());`
	`450`	`+ v.append(&mut types.iter().flat_map(\|t\| t.as_bytes()).collect());`
`451`	`451`	`let v = dbg!(v);`
`452`	`452`	`v`
`453`	`453`	`}`
`@@ -470,7 +470,7 @@ impl StackMapFrame {`
`470`	`470`	`}`
`471`	`471`	`}`
`472`	`472`	`}`
`473`		`-`
	`473`	`+#[allow(clippy::upper_case_acronyms)]`
`474`	`474`	`#[derive(Debug, Clone, PartialEq)]`
`475`	`475`	`pub(crate) enum VerificationType {`
`476`	`476`	`TOP,`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
	`1`	`+#[allow(clippy::module_inception)]`
`1`	`2`	`mod parser;`
`2`	`3`	`pub use parser::*;`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
	`1`	`+#[allow(clippy::module_inception)]`
`1`	`2`	`pub mod typechecker;`