my initial short for typechecking, still very unifinished tho

src/main/java/de/hsrm/compiler/Klang/ContextAnalysis.java

@@ -1,7 +1,7 @@
 package de.hsrm.compiler.Klang;
 
-import java.util.Set;
-import java.util.HashSet;
+import java.util.Map;
+import java.util.HashMap;
 
 import de.hsrm.compiler.Klang.nodes.*;
 import de.hsrm.compiler.Klang.nodes.expressions.*;
@@ -12,7 +12,9 @@ import de.hsrm.compiler.Klang.nodes.statements.*;
 import de.hsrm.compiler.Klang.types.Type;
 
 public class ContextAnalysis extends KlangBaseVisitor<Node> {
-  Set<String> vars = new HashSet<>();
+  Map<String, VariableDeclaration> vars = new HashMap<>();
+  Map<String, FunctionDefinition> funcs = new HashMap<>();
+  Type currentDeclaredReturnType;
 
   @Override
   public Node visitProgram(KlangParser.ProgramContext ctx) {
@@ -21,7 +23,9 @@ public class ContextAnalysis extends KlangBaseVisitor<Node> {
       funcs[i] = (FunctionDefinition) this.visit(ctx.functionDef(i));
     }
     Expression expression = (Expression) this.visit(ctx.expression());
-    return new Program(funcs, expression);
+    Program result = new Program(funcs, expression); 
+    result.type = expression.type;
+    return result;
   }
 
   @Override
@@ -33,39 +37,77 @@ public class ContextAnalysis extends KlangBaseVisitor<Node> {
 
   @Override
   public Node visitBraced_block(KlangParser.Braced_blockContext ctx) {
-    Statement[] statements = new Statement[ctx.statement().size()];
-    
-    for (int i = 0; i < ctx.statement().size(); i++) {
-      var stmtCtx = ctx.statement(i);
-      Node currentStatement = this.visit(stmtCtx);
+    int actualStatementCount = 0;
+    int declaredStatementCount = ctx.statement().size();
+    boolean hasReturn = false;
+    Statement[] statements = new Statement[declaredStatementCount];
+
+    for (int i = 0; i < declaredStatementCount; i++) {
+      Node currentStatement = this.visit(ctx.statement(i));
       statements[i] = (Statement) currentStatement;
+      actualStatementCount += 1;
+
+      // We use the existance of a type to indicate that this statement returns something
+      // for which the VariableDeclaration is an exception
+      if (currentStatement.type != null && !(currentStatement instanceof VariableDeclaration)) {
+        // check whether the type matches
+        this.currentDeclaredReturnType.combine(currentStatement.type);
+
+        // since we have a return guaranteed, every statement after this one is unreachable code
+        hasReturn = true;
+        break;
+      }
     }
 
+    // If there was unreachable code in this block,
+    // create a shorter statements array and copy the statements to there
+    if (actualStatementCount < declaredStatementCount) {
+      Statement[] newStatements = new Statement[actualStatementCount];
+      for (int i = 0; i < actualStatementCount; i++) {
+        newStatements[i] = statements[i];
+      }
+      statements = newStatements;
+    }
+
+    // if this block contains at least one statement that guarantees a return value,
+    // we indicate that this block guarantees a return value by setting result.type
     Block result = new Block(statements);
-    result.type = null;
+    if (hasReturn) {
+      result.type = this.currentDeclaredReturnType;
+    }
+
     return result;
   }
 
   @Override
   public Node visitPrint(KlangParser.PrintContext ctx) {
     Node expression = this.visit(ctx.expression());
-    return new PrintStatement((Expression) expression);
+    PrintStatement result = new PrintStatement((Expression) expression); 
+    result.type = expression.type;
+    return result;
   }
 
   @Override
   public Node visitIf_statement(KlangParser.If_statementContext ctx) {
     Node condition = this.visit(ctx.cond);
     Node thenBlock = this.visit(ctx.then);
+    Type type = thenBlock.type;
 
+    IfStatement result;
     if (ctx.alt != null) {
       Node elseBlock = this.visit(ctx.alt);
-      return new IfStatement((Expression) condition, (Block) thenBlock, (Block) elseBlock);
+      result = new IfStatement((Expression) condition, (Block) thenBlock, (Block) elseBlock);
+      type = type.combine(elseBlock.type);
     } else if (ctx.elif != null) {
       Node elif = this.visit(ctx.elif);
-      return new IfStatement((Expression) condition, (Block) thenBlock, (IfStatement) elif);
+      result = new IfStatement((Expression) condition, (Block) thenBlock, (IfStatement) elif);
+      type = type.combine(elif.type);
     } else {
-      return new IfStatement((Expression) condition, (Block) thenBlock);
+      result = new IfStatement((Expression) condition, (Block) thenBlock);
     }
+
+    result.type = type;
+    return result;
   }
 
   @Override
@@ -94,122 +136,201 @@ public class ContextAnalysis extends KlangBaseVisitor<Node> {
   @Override
   public Node visitVariable_declaration(KlangParser.Variable_declarationContext ctx) {
     String name = ctx.IDENT().getText();
+    Type declaredType = Type.getByName(ctx.type_annotation().type().getText());
 
-    if (this.vars.contains(name)) {
-      throw new RuntimeException("Redeclaration of variable with name \"" + name +"\".");
+    if (this.vars.get(name) != null) {
+      throw new RuntimeException("Redeclaration of variable with name \"" + name + "\".");
     }
 
-    this.vars.add(name);
-
+    // Create the appropriate instance
+    VariableDeclaration result;
     if (ctx.expression() != null) {
-      return new VariableDeclaration(name, (Expression) this.visit(ctx.expression()));
+      Node expression = this.visit(ctx.expression());
+      declaredType = declaredType.combine(expression.type);
+      result = new VariableDeclaration(name, (Expression) expression);
+      result.type = declaredType; // add the type only if there is an expression
     } else {
-      return new VariableDeclaration(name);
+      result = new VariableDeclaration(name);
     }
+
+    // Add it to the global map of variable declarations
+    this.vars.put(name, result);
+
+    return result;
   }
 
   @Override
   public Node visitVariable_assignment(KlangParser.Variable_assignmentContext ctx) {
     String name = ctx.IDENT().getText();
 
-    if (!this.vars.contains(name)) {
+    VariableDeclaration var = this.vars.get(name);
+    if (var == null) {
       throw new RuntimeException("Variable with name \"" + name + "\" not defined.");
     }
 
+    // Evaluate the expression
     Expression expression = (Expression) this.visit(ctx.expression());
+
+    // Make sure expression can be assigned to the variable
+    expression.type.combine(var.type);
+
+    // Create a new node and add the type of the expression to it
     return new VariableAssignment(name, expression);
   }
 
   @Override
   public Node visitReturn_statement(KlangParser.Return_statementContext ctx) {
     Expression expression = (Expression) this.visit(ctx.expression());
-    return new ReturnStatement(expression);
+    ReturnStatement result = new ReturnStatement(expression);
+    result.type = expression.type;
+    return result;
   }
 
   @Override
   public Node visitOrExpression(KlangParser.OrExpressionContext ctx) {
-    return new OrExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    OrExpression result = new OrExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitAndExpression(KlangParser.AndExpressionContext ctx) {
-    return new AndExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    AndExpression result = new AndExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitAdditionExpression(KlangParser.AdditionExpressionContext ctx) {
-    return new AdditionExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    AdditionExpression result = new AdditionExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
-  @Override 
-  public Node visitEqualityExpression(KlangParser.EqualityExpressionContext ctx) { 
-    return new EqualityExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  @Override
+  public Node visitEqualityExpression(KlangParser.EqualityExpressionContext ctx) {
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    EqualityExpression result = new EqualityExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
-  @Override 
-  public Node visitNotEqualityExpression(KlangParser.NotEqualityExpressionContext ctx) { 
-    return new NotEqualityExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  @Override
+  public Node visitNotEqualityExpression(KlangParser.NotEqualityExpressionContext ctx) {
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    NotEqualityExpression result = new NotEqualityExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
-  @Override 
-  public Node visitLessThanExpression(KlangParser.LessThanExpressionContext ctx) { 
-    return new LTExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  @Override
+  public Node visitLessThanExpression(KlangParser.LessThanExpressionContext ctx) {
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    LTExpression result = new LTExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
-  @Override 
-  public Node visitGreaterThanExpression(KlangParser.GreaterThanExpressionContext ctx) { 
-    return new GTExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  @Override
+  public Node visitGreaterThanExpression(KlangParser.GreaterThanExpressionContext ctx) {
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    GTExpression result = new GTExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
-  @Override 
-  public Node visitLessThanOrEqualToExpression(KlangParser.LessThanOrEqualToExpressionContext ctx) { 
-    return new LTEExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  @Override
+  public Node visitLessThanOrEqualToExpression(KlangParser.LessThanOrEqualToExpressionContext ctx) {
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    LTEExpression result = new LTEExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
-  @Override 
-  public Node visitGreaterThanOrEqualToExpression(KlangParser.GreaterThanOrEqualToExpressionContext ctx) { 
-    return new GTEExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  @Override
+  public Node visitGreaterThanOrEqualToExpression(KlangParser.GreaterThanOrEqualToExpressionContext ctx) {
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    GTEExpression result = new GTEExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitSubstractionExpression(KlangParser.SubstractionExpressionContext ctx) {
-    return new SubstractionExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    SubstractionExpression result = new SubstractionExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitMultiplicationExpression(KlangParser.MultiplicationExpressionContext ctx) {
-    return new MultiplicationExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    MultiplicationExpression result = new MultiplicationExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitDivisionExpression(KlangParser.DivisionExpressionContext ctx) {
-    return new DivisionExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    DivisionExpression result = new DivisionExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitModuloExpression(KlangParser.ModuloExpressionContext ctx) {
-    return new ModuloExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+    Node lhs = this.visit(ctx.lhs);
+    Node rhs = this.visit(ctx.rhs);
+    ModuloExpression result = new ModuloExpression((Expression) lhs, (Expression) rhs);
+    result.type = lhs.type.combine(rhs.type);
+    return result;
   }
 
   @Override
   public Node visitNegateExpression(KlangParser.NegateExpressionContext ctx) {
-    return new NegateExpression((Expression) this.visit(ctx.expression()));
+    Node expression = this.visit(ctx.expression());
+    NegateExpression result = new NegateExpression((Expression) expression);
+    result.type = expression.type;
+    return result;
   }
 
   @Override
   public Node visitNotExpression(KlangParser.NotExpressionContext ctx) {
-    return new NotExpression((Expression) this.visit(ctx.expression()));
+    Node expression = this.visit(ctx.expression());
+    NotExpression result = new NotExpression((Expression) expression);
+    result.type = expression.type;
+    return result;
   }
 
   @Override
   public Node visitVariable(KlangParser.VariableContext ctx) {
     String name = ctx.IDENT().getText();
 
-    if (!this.vars.contains(name)) {
+    VariableDeclaration var = this.vars.get(name);
+    if (var == null) {
       throw new RuntimeException("Variable with name \"" + name + "\" not defined.");
     }
 
-    return new Variable(ctx.IDENT().getText());
+    Variable result = new Variable(ctx.IDENT().getText());
+    result.type = var.type;
+    return result;
   }
 
   @Override
@@ -234,28 +355,81 @@ public class ContextAnalysis extends KlangBaseVisitor<Node> {
   @Override
   public Node visitFunctionDef(KlangParser.FunctionDefContext ctx) {
     String name = ctx.funcName.getText();
+    Type returnType = Type.getByName(ctx.returnType.type().getText());
+    this.currentDeclaredReturnType = returnType;
 
     // Create a new set for the variables of the current function
     // this will be filled in the variable declaration visitor aswell
-    this.vars = new HashSet<>();
+    this.vars = new HashMap<>();
 
-    String[] params = new String[ctx.parameters().IDENT().size()];
-    for (int i = 0; i < ctx.parameters().IDENT().size(); i++) {
-      String paramName = ctx.parameters().IDENT(i).getText();
-      params[i] = paramName;
-      this.vars.add(paramName); // add the param as a variable
+    // Process the paremter list by visiting every paremter in it
+    int paramCount = ctx.params.parameter().size();
+    Parameter[] params = new Parameter[paramCount];
+    for (int i = 0; i < paramCount; i++) {
+      // Add the parameter to the list of parameters
+      Parameter param = (Parameter) this.visit(ctx.params.parameter(i));
+      params[i] = param;
+
+      // add the param as a variable
+      VariableDeclaration var = new VariableDeclaration(param.name);
+      var.type = param.type;
+      this.vars.put(param.name, var);
     }
+
+    // Visit the block, make sure the types are matching
     Node block = this.visit(ctx.braced_block());
-    return new FunctionDefinition(name, params, (Block) block);
+    block.type.combine(returnType);
+
+    FunctionDefinition result = new FunctionDefinition(name, params, (Block) block);
+    result.type = returnType;
+
+    // Add this function to our environment
+    
+    // TODO
+    // Geht nicht weil das bei ner Rekursion um die ohren fliegt,
+    // der funktionsprototyp muss in die funcs geschrieben werden,
+    // bevor der block gevisited wird
+    this.funcs.put(name, result);
+
+    return result;
+  }
+
+  @Override
+  public Node visitParameter(KlangParser.ParameterContext ctx) {
+    String name = ctx.IDENT().getText();
+    Type type = Type.getByName(ctx.type_annotation().type().getText());
+    Parameter result = new Parameter(name);
+    result.type = type;
+    return result;
   }
 
   @Override
   public Node visitFunctionCallExpression(KlangParser.FunctionCallExpressionContext ctx) {
     String name = ctx.functionCall().IDENT().getText();
-    Expression[] args = new Expression[ctx.functionCall().arguments().expression().size()];
-    for (int i = 0; i < ctx.functionCall().arguments().expression().size(); i++) {
-      args[i] = (Expression) this.visit(ctx.functionCall().arguments().expression(i));
+
+    // Make sure the function that is called is defined
+    FunctionDefinition func = this.funcs.get(name);
+    if (func == null) {
+      throw new RuntimeException("Function with name \"" + name + "\" not defined.");
     }
-    return new FunctionCall(name, args);
+
+    // Make sure the number of arguments matches the number of parameters
+    int argCount = ctx.functionCall().arguments().expression().size();
+    int paramCount = func.parameters.length;
+    if (argCount != paramCount) {
+      throw new RuntimeException("Function \"" + name + "\" expects " + paramCount + " parameters, but got " + argCount + ".");
+    }
+
+    // Evaluate every argument
+    Expression[] args = new Expression[argCount];
+    for (int i = 0; i < argCount; i++) {
+      Expression expression = (Expression) this.visit(ctx.functionCall().arguments().expression(i)); 
+      expression.type.combine(func.parameters[i].type); // Make sure the types are matching
+      args[i] = expression;
+    }
+
+    FunctionCall result = new FunctionCall(name, args);
+    result.type = func.type;
+    return result;
   }
 }

src/main/java/de/hsrm/compiler/Klang/nodes/FunctionDefinition.java

@@ -5,16 +5,15 @@ import de.hsrm.compiler.Klang.visitors.Visitor;
 public class FunctionDefinition extends Node {
 
   public String name;
-  public String[] parameters;
+  public Parameter[] parameters;
   public Block block;
 
-  public FunctionDefinition(String name, String[] parameters, Block block) {
+  public FunctionDefinition(String name, Parameter[] parameters, Block block) {
     this.name = name;
     this.parameters = parameters;
     this.block = block;
   }
 
-
   @Override
   public <R> R welcome(Visitor<R> v) {
     return v.visit(this);

src/main/java/de/hsrm/compiler/Klang/nodes/Parameter.java

@@ -0,0 +1,17 @@
+package de.hsrm.compiler.Klang.nodes;
+
+import de.hsrm.compiler.Klang.visitors.Visitor;
+
+public class Parameter extends Node {
+
+  public String name;
+
+  public Parameter(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public <R> R welcome(Visitor<R> v) {
+    return v.visit(this);
+  }
+}

src/main/java/de/hsrm/compiler/Klang/nodes/loops/DoWhileLoop.java

@@ -9,7 +9,6 @@ public class DoWhileLoop extends Statement {
 
     public Expression cond;
     public Block block;
-    public Block alt;
 
     public DoWhileLoop(Expression cond, Block block) {
         this.cond = cond;

src/main/java/de/hsrm/compiler/Klang/types/BooleanType.java

@@ -17,4 +17,20 @@ public class BooleanType extends PrimitiveType {
     return true;
   }
 
+  @Override
+  public String getName() {
+    return "bool";
+  }
+
+  @Override
+  public Type combine(Type that) {
+    // Combining two equal types always works
+    if (that.equals(this)) {
+      return this;
+    }
+
+    // Every remaining type will throw a RuntimeException
+    throw new RuntimeException("Type missmatch: cannot combine " + this.getName() + " and " + that.getName());
+  }
+
 }

src/main/java/de/hsrm/compiler/Klang/types/IntegerType.java

@@ -17,4 +17,23 @@ public class IntegerType extends PrimitiveType {
     return true;
   }
 
+  @Override
+  public String getName() {
+    return "int";
+  }
+
+  @Override
+  public Type combine(Type that) {
+    // Combining two equal types always works
+    if (that.equals(this)) {
+      return this;
+    }
+
+    // Check other possible combinations
+    // if (that.equals(Type.getFloatType())) return Type.getFloatType();
+
+    // Every remaining type will throw a RuntimeException
+    throw new RuntimeException("Type missmatch: cannot combine " + this.getName() + " and " + that.getName());
+  }
+
 }

src/main/java/de/hsrm/compiler/Klang/types/Type.java

@@ -12,5 +12,15 @@ public abstract class Type {
     return BooleanType.getType();
   }
 
+  public static Type getByName(String name) {
+    switch (name) {
+      case "bool": return getBooleanType();
+      case "int": return getIntegerType();
+      default: throw new RuntimeException("Unknown type " + name);
+    }
+  }
+
+  public abstract String getName();
+  public abstract Type combine(Type that);
   public abstract boolean isPrimitiveType();
 }

src/main/java/de/hsrm/compiler/Klang/visitors/EvalVisitor.java

@@ -6,6 +6,7 @@ import java.util.Map;
 import de.hsrm.compiler.Klang.Value;
 import de.hsrm.compiler.Klang.nodes.Block;
 import de.hsrm.compiler.Klang.nodes.FunctionDefinition;
+import de.hsrm.compiler.Klang.nodes.Parameter;
 import de.hsrm.compiler.Klang.nodes.Program;
 import de.hsrm.compiler.Klang.nodes.expressions.*;
 import de.hsrm.compiler.Klang.nodes.loops.DoWhileLoop;
@@ -211,7 +212,7 @@ public class EvalVisitor implements Visitor<Value> {
       e.step.welcome(this);
       cond = e.condition.welcome(this);
     }
-    
+
     return result;
   }
 
@@ -278,7 +279,7 @@ public class EvalVisitor implements Visitor<Value> {
     // Baue ein neues environment
     Map<String, Value> newEnv = new HashMap<>();
     for (int i = 0; i < func.parameters.length; i++) {
-      newEnv.put(func.parameters[i], e.arguments[i].welcome(this));
+      newEnv.put(func.parameters[i].name, e.arguments[i].welcome(this));
     }
     var oldEnv = this.env;
     this.env = newEnv;
@@ -303,4 +304,9 @@ public class EvalVisitor implements Visitor<Value> {
     return e.expression.welcome(this);
   }
 
+  @Override
+  public Value visit(Parameter e) {
+    return null;
+  }
+
 }

src/main/java/de/hsrm/compiler/Klang/visitors/GenASM.java

@@ -507,7 +507,7 @@ public class GenASM implements Visitor<Void> {
     int offset = 16; // Per Stack übergebene Parameter liegen über unserm BSP
     // Per stack übergebene variablen in env registrieren
     for (int i = this.rs.length; i < e.parameters.length; i++) {
-      env.put(e.parameters[i], offset);
+      env.put(e.parameters[i].name, offset);
       offset += 8;
     }
 
@@ -516,7 +516,7 @@ public class GenASM implements Visitor<Void> {
     for (int i = 0; i < Math.min(this.rs.length, e.parameters.length); i++) {
       this.ex.write("    pushq " + this.rs[i] + "\n");
       offset -= 8;
-      this.env.put(e.parameters[i], offset); // negative, liegt unter aktuellem BP
+      this.env.put(e.parameters[i].name, offset); // negative, liegt unter aktuellem BP
     }
 
     // Reserviere Platz auf dem Stack für jede lokale variable
@@ -568,4 +568,11 @@ public class GenASM implements Visitor<Void> {
     return null;
   }
 
+  @Override
+  public Void visit(Parameter e) {
+    // The work for a paremeter node is implement
+    // in the function definition visitor
+    return null;
+  }
+
 }

src/main/java/de/hsrm/compiler/Klang/visitors/GetVars.java

@@ -225,4 +225,9 @@ class GetVars implements Visitor<Void> {
     return null;
   }
 
+  @Override
+  public Void visit(Parameter e) {
+    return null;
+  }
+
 }

src/main/java/de/hsrm/compiler/Klang/visitors/PrettyPrintVisitor.java

@@ -328,13 +328,15 @@ public class PrettyPrintVisitor implements Visitor<Void> {
     ex.write(e.name);
     ex.write("(");
     boolean first = true;
-    for (String param : e.parameters) {
+    for (Parameter param : e.parameters) {
       if (!first) {
         ex.write(", ");
       } else {
         first = false;
       }
-      ex.write(param);
+      ex.write(param.name);
+      ex.write(":");
+      ex.write(param.type.getName());
     }
     ex.write(") ");
     e.block.welcome(this);
@@ -364,4 +366,10 @@ public class PrettyPrintVisitor implements Visitor<Void> {
     return null;
   }
 
+  @Override
+  public Void visit(Parameter e) {
+    // The work is already done in the function definition visitor
+    return null;
+  }
+
 }

src/main/java/de/hsrm/compiler/Klang/visitors/Visitor.java

@@ -2,6 +2,7 @@ package de.hsrm.compiler.Klang.visitors;
 
 import de.hsrm.compiler.Klang.nodes.Block;
 import de.hsrm.compiler.Klang.nodes.FunctionDefinition;
+import de.hsrm.compiler.Klang.nodes.Parameter;
 import de.hsrm.compiler.Klang.nodes.Program;
 import de.hsrm.compiler.Klang.nodes.expressions.*;
 import de.hsrm.compiler.Klang.nodes.loops.*;
@@ -38,4 +39,5 @@ public interface Visitor<R> {
     R visit(FunctionDefinition e);
     R visit(FunctionCall e);
     R visit(Program e);
+    R visit(Parameter e);
 }