Merge pull request #14 from Java-rs/typechecking

Typechecking

Author: Flippchen

docs/Project-Doc.md

@@ -1,11 +1,46 @@
+## Supported types
+- Welche Types, Strukturen und deren Kombinationen werden unterstützt?
+
 ## Parser
 
 -   Wer hat welche Arbeit am Parser gemacht?
 -   Wie wurde Pest fürs Parsing eingesetzt? (sehr ähnlich zu ANTLR)
 
 ## Typchecker
 
--   Wer hat welche Arbeit am Typchecker gemacht?
+Geschrieben von: Maximilian Floto, Philipp Wolf
+
+Der Typechecker akzeptiert einen Abstract Syntax Tree (AST) und gibt einen getypten AST (TAST) zurück.
+Er führt eine umfassende Analyse durch, um die Typen aller Variablen und Ausdrücke im Code zu bestimmen.
+Er stellt sicher, dass jede Variable vor ihrer Verwendung korrekt deklariert und initialisiert wurde, wodurch potenzielle Fehler in der Anwendung vermieden werden.
+Er bestimmt die Typen aller Ausdrücke und Variablen und überprüft, ob alle Variablen vor ihrer Verwendung korrekt deklariert und initialisiert wurden.
+
+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
+
+
+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
 
 ## Codegenerierung
 

docs/User-Doc.md

@@ -7,6 +7,12 @@ TBD
 
 ## Typchecker
 
+1. Projekt bauen: `cargo build`
+2. Go to lib folder: `cd lib`
+3. Typechecker tests ausführen: `cargo test test_typechecker`
+
+Spezifischen Test ausführen: `cargo test <test_name>::test_typechecker`
+
 ## Codegenerierung
 
 ## Testing

lib/src/codegen/bytecode.rs

@@ -1,4 +1,5 @@
+#![allow(unused)]
 //! Utilities for bytecode generation
 
-use crate::codegen::ir::*;
-use crate::types::*;
+// use crate::codegen::ir::*;
+// use crate::types::*;

lib/src/codegen/ir.rs

@@ -1,4 +1,6 @@
 #![allow(non_camel_case_types)]
+#![allow(unused)]
+#![allow(non_snake_case)]
 
 use crate::typechecker::*;
 use crate::types;

lib/src/parser/JavaGrammar.pest

@@ -6,14 +6,16 @@ Program = {ClassDecl+}
 
 ClassDecl = {"class" ~ Identifier ~ "{" ~ (MethodDecl|FieldDecl)* ~ "}"}
 
-FieldDecl = {JType ~ FieldVarDecl+}
+FieldDecl = {JType ~ FieldVarDeclList ~ ";"}
 
 MethodDecl = {JType ~ Identifier ~ "(" ~ ParamDeclList? ~ ")" ~ BlockStmt}
 
 ParamDeclList = {ParamDecl ~ (","~ParamDecl)*}
 
 ParamDecl = {JType ~ Identifier}
 
+FieldVarDeclList = {FieldVarDecl ~ (","~FieldVarDeclList)*}
+
 FieldVarDecl = {Identifier ~ ("="~Expr)?}
 
 JType = {PrimitiveType | Identifier}
@@ -56,27 +58,29 @@ MethodCallExpr = {(Identifier|InstVarExpr) ~ "(" ~ ParamList? ~ ")"}
 ParamList = {Expr ~ (","~Expr)*}
 
 // @Note we do not support `super` at the moment
-Expr = {Prec3BinExpr | NonBinaryExpr}
+Expr = {NonBinaryExpr | Prec3BinExpr}
 
 NonBinaryExpr = { ThisExpr
-		        | Identifier // LocalOrFieldVar
+		        | JNull
 		        | InstVarExpr
 		        | UnaryExpr
+		        | ParanthesizedExpr
 		        | IntLiteral
 		        | BoolLiteral
 		        | CharLiteral
 		        | StrLiteral
-		        | JNull
-		        | ParanthesizedExpr
+		        | Identifier // LocalOrFieldVar
 		        | StmtExpr}
 
 ThisExpr = {"this"}
 JNull    = {"null"}
 
 IntLiteral  = {NUMBER+}
 BoolLiteral = {"true" | "false"}
-CharLiteral = {"'" ~ ASCII ~ "'"}
-StrLiteral  = {"\"" ~ ASCII* ~ "\""}
+CharLiteral = { "'"  ~ (!("'"  | "\\") ~ ANY | EscapedChar) ~ "'"}
+StrLiteral  = { "\"" ~ (!("\"" | "\\") ~ ANY | EscapedChar)* ~ "\""}
+EscapedChar = { "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t")
+    		  | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})}
 
 InstVarExpr      = {(Identifier|ThisExpr) ~ "." ~ InnerInstVarExpr}
 InnerInstVarExpr = {Identifier ~ ("." ~ (InnerInstVarExpr|Identifier))?}

lib/src/parser/mod.rs

@@ -1,5 +1,2 @@
 mod parser;
-#[cfg(test)]
-mod test;
-
 pub use parser::*;

lib/src/parser/parser.rs

@@ -1,3 +1,7 @@
+#![allow(non_camel_case_types)]
+#![allow(unused)]
+#![allow(non_snake_case)]
+
 extern crate pest;
 extern crate pest_derive;
 
@@ -11,7 +15,7 @@ use pest_derive::Parser;
 #[grammar = "../lib/src/parser/JavaGrammar.pest"]
 struct ExampleParser;
 
-pub fn parse_Programm(file: &str) -> Result<Vec<Class>, Error<Rule>> {
+pub fn parse_programm(file: &str) -> Result<Vec<Class>, Error<Rule>> {
     let example: Pair<Rule> = ExampleParser::parse(Rule::Program, file)?.next().unwrap();
 
     if example.as_rule() != Rule::Program {
@@ -53,7 +57,7 @@ fn next_id(inners: &mut Pairs<Rule>) -> String {
     // calling to_string() immediately would return "Identifier(<location>)",
     // while as_str() returns the actual str-slice captured by the Identifier-rule
     // We still have to copy that str-slice into its own string object with to_string() though
-    inners.next().unwrap().as_str().to_string()
+    inners.next().unwrap().as_str().trim().to_string()
 }
 
 fn parse_method(pair: Pair<Rule>) -> MethodDecl {
@@ -142,33 +146,31 @@ fn parse_field(pair: Pair<Rule>) -> Vec<FieldDecl> {
     match pair.as_rule() {
         Rule::FieldDecl => {
             let mut inners = pair.into_inner();
-            let JType = parse_Type(inners.next().unwrap());
-            let varDecels = inners.next().unwrap().into_inner();
-
-            varDecels
-                .map(|x| {
-                    let mut inner = x.into_inner();
-                    let other_name = next_id(&mut inner);
-                    match inner.next() {
-                        None => FieldDecl {
-                            field_type: JType.clone(),
-                            name: other_name,
-                            val: None,
-                        },
-                        Some(val) => FieldDecl {
-                            field_type: JType.clone(),
-                            name: other_name,
-                            val: Some(parse_expr(val)),
-                        },
-                    }
-                })
-                .collect()
+            let jtype = parse_Type(inners.next().unwrap());
+            parse_field_var_decl_list(jtype, inners.next().unwrap())
         }
 
         _ => unreachable!(),
     }
 }
 
+fn parse_field_var_decl_list(jtype: Type, pair: Pair<Rule>) -> Vec<FieldDecl> {
+    assert_eq!(pair.as_rule(), Rule::FieldVarDeclList);
+    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 mut out = vec![FieldDecl {
+        field_type: jtype.clone(),
+        name,
+        val,
+    }];
+    if let Some(p) = inners.next() {
+        out.append(&mut parse_field_var_decl_list(jtype, p));
+    }
+    return out;
+}
+
 fn parse_Type(pair: Pair<Rule>) -> Type {
     match pair.as_rule() {
         Rule::JType => parse_Type(pair.into_inner().next().unwrap()),
@@ -185,9 +187,26 @@ fn parse_Type(pair: Pair<Rule>) -> Type {
         _ => unreachable!(),
     }
 }
+
 fn parse_expr(pair: Pair<Rule>) -> Expr {
-    todo!()
+    println!("{:?}", pair);
+    match pair.as_rule() {
+        Rule::Expr => parse_expr(pair.into_inner().next().unwrap()),
+        Rule::NonBinaryExpr => parse_expr(pair.into_inner().next().unwrap()),
+        Rule::IntLiteral => Expr::Integer(pair.as_str().parse().unwrap()),
+        Rule::BoolLiteral => Expr::Bool(pair.as_str().parse().unwrap()),
+        Rule::CharLiteral => Expr::Char(get_str_content(pair.as_str()).parse().unwrap()),
+        Rule::StrLiteral => Expr::String(get_str_content(pair.as_str()).to_string()),
+        Rule::JNull => Expr::Jnull,
+        Rule::ThisExpr => Expr::This,
+        _ => todo!(),
+    }
 }
+
+fn get_str_content(s: &str) -> &str {
+    &s[1..s.len() - 1]
+}
+
 fn parse_value(pair: Pair<Rule>) -> Expr {
     match pair.as_rule() {
         // Rule::ID => Example::ID(String::from(pair.as_str())),