TypeCheckingVisitor.java

import java.util.LinkedHashMap;
import java.util.Iterator;
import java.util.List;

import syntaxtree.*;
import visitor.GJDepthFirst;


/*This visitor checks: Inheritance, Circular Dependency, 
Type checking in expressions, statements, methods,conditions */
public class TypeCheckingVisitor extends GJDepthFirst <String, Argu>{
    LinkedHashMap<String,ClassInfo> symbolTable;

    /*getting the symbol table from v1 */
    public TypeCheckingVisitor(LinkedHashMap<String, ClassInfo> symbolTable){
        this.symbolTable = symbolTable;

    }
    
    /*HELPER FUNCTIONS */
    /*Helper that checks whether var1 is subtype of var2 or of the same type*/
    boolean checkType(String var1, String var2){
       //same type
        if(var1.equals(var2)){
            return true;
        }
        ClassInfo cInfo=symbolTable.get(var1);
        //no such class
        if (cInfo==null){
            return false;
        }
        //doesnt have a parent so type doesnt exist for sure
        if(cInfo.parent==null){
            return false;
        }
        //go up through the  parents to check
        return checkType(cInfo.parent, var2);

    }

/*Helper that checks whether a method was declared in a class or any of its parents */
/*Returns the MethodInfo list or null if Method doesnt exist anywhere*/
    List<MethodInfo> checkMethod(String classname, String methodname){
        //in the class
        if(symbolTable.get(classname).methods.containsKey(methodname)){
            return symbolTable.get(classname).methods.get(methodname);
        }
        //in parent
        String parentname=symbolTable.get(classname).parent;
        if(parentname!=null){
            return checkMethod(parentname, methodname);
        }
        return null;
    }

    //returns the current method from the MethodInfo list
    // last added is the current one
    MethodInfo getCurrentMethod(String className, String methodName){
        List<MethodInfo> list = symbolTable.get(className).methods.get(methodName);
        return list.get(list.size() - 1);  
    }




    

/*VISIT FUNCTIONS */

    /*Main Class */
    /**
 * Grammar production:
 * f0 -> "class"
 * f1 -> Identifier()
 * f2 -> "{"
 * f3 -> "public"
 * f4 -> "static"
 * f5 -> "void"
 * f6 -> "main"
 * f7 -> "("
 * f8 -> "String"
 * f9 -> "["
 * f10 -> "]"
 * f11 -> Identifier()
 * f12 -> ")"
 * f13 -> "{"
 * f14 -> ( VarDeclaration() )*
 * f15 -> ( Statement() )*
 * f16 -> "}"
 * f17 -> "}"
 */
    @Override
    public String visit(MainClass mc, Argu argu){
        String classname=mc.f1.f0.toString();
        Argu argu2=new Argu(classname,"main");
        mc.f15.accept(this, argu2);
        return null;
    }



    /*CLASS DECLARATION */
    /**
 * Grammar production:
 * f0 -> "class"
 * f1 -> Identifier()
 * f2 -> "{"
 * f3 -> ( VarDeclaration() )*
 * f4 -> ( MethodDeclaration() )*
 * f5 -> "}"
 */

    @Override
    public String visit(ClassDeclaration cd, Argu argu){
        String classname=cd.f1.f0.toString();
        Argu argu2=new Argu(classname, null);
        cd.f4.accept(this, argu2);
        return null;
    }



        /*CLASS EXTENDS DECLARATION */
    /**
     * Grammar production:
     * f0 -> "class"
     * f1 -> Identifier()
     * f2 -> "extends"
     * f3 -> Identifier()
     * f4 -> "{"
     * f5 -> ( VarDeclaration() )*
     * f6 -> ( MethodDeclaration() )*
     * f7 -> "}"
     */
    @Override
    public String visit(ClassExtendsDeclaration ced, Argu argu){
        String classname=ced.f1.f0.toString();
        String parentclassname=ced.f3.f0.toString();

        //Check that Parent was actually declared before
        if(!symbolTable.containsKey(parentclassname)){
            throw new RuntimeException("Undefined class: "+parentclassname+"\n");
        }

        // Check for circular dependency
        String current= classname;
        while(current!=null){
            current= symbolTable.get(current).parent;
            if(current!=null && current.equals(classname) ){
                throw new RuntimeException("Circular dependency between: "+classname+" "+parentclassname+"\n");
            }
        }

        Argu argu2=new Argu(classname,null);
        ced.f5.accept(this,argu2);
        ced.f6.accept(this,argu2);      
        return null;
    }

    /*METHOD DECLARATION */
/**
 * Grammar production:
 * f0 -> "public"
 * f1 -> Type()
 * f2 -> Identifier()
 * f3 -> "("
 * f4 -> ( FormalParameterList() )?
 * f5 -> ")"
 * f6 -> "{"
 * f7 -> ( VarDeclaration() )*
 * f8 -> ( Statement() )*
 * f9 -> "return"
 * f10 -> Expression()
 * f11 -> ";"
 * f12 -> "}"
 */
    @Override
    public String visit(MethodDeclaration md, Argu argu){
        String methodname=md.f2.f0.toString();    
        String methodtype=md.f1.accept(this,argu);

        //type validity
       if(!methodtype.equals("int")&& !methodtype.equals("boolean") && !methodtype.equals("int[]")){
            //doesnt exist as a class either
            if(!symbolTable.containsKey(methodtype)){
                throw new RuntimeException("No such type: "+methodtype+"\n");
            }
        }

        //retur type check
        Argu argu2= new Argu(argu.className, methodname);
        md.f4.accept(this, argu2);
        md.f8.accept(this,argu2);
        String returntype= md.f10.accept(this,argu2);
        if(!checkType(returntype,methodtype)){
            throw new RuntimeException("In method: "+methodname+": Method Type != Return Type: "+methodtype+" "+returntype+"\n");
        }
        return null;

    }

/*Var Declaration */


/**
 * Grammar production:
 * f0 -> Type()
 * f1 -> Identifier()
 * f2 -> ";"
 */

    @Override
    public String visit(VarDeclaration vd, Argu argu){
        String type=vd.f0.accept(this, argu);
        //type validity
        if(!type.equals("int")&& !type.equals("boolean") && !type.equals("int[]")){
            //doesnt exist as a class either
            if(!symbolTable.containsKey(type)){
                throw new RuntimeException("No such type: "+type+"\n");
            }
        }
        return null;
    }


    /*FORMAL PARAMETER */
    /**
 * Grammar production:
 * f0 -> Type()
 * f1 -> Identifier()
 */
    @Override
    public String visit(FormalParameter fp, Argu argu){
        String parametertype=fp.f0.accept(this,argu);
        if(!parametertype.equals("int")&& !parametertype.equals("boolean")&& !parametertype.equals("int[]")){
            if(!symbolTable.containsKey(parametertype)){
                throw new RuntimeException("No such type: "+parametertype+"\n");
            }

        }
        return null;
    }



    /*STATEMENTS */

    /*Assignment Statement */
    /**
 * Grammar production:
 * f0 -> Identifier()
 * f1 -> "="
 * f2 -> Expression()
 * f3 -> ";"
 */

    @Override
    public String visit(AssignmentStatement as, Argu argu){
        String leftType=as.f0.accept(this,argu);
        String rightType=as.f2.accept(this,argu);
        if(!checkType(rightType, leftType )){
            throw new RuntimeException("Type mismatch Id=Expr: "+leftType+" = "+rightType+"\n Expected: Expr=subtype of Id\n ");
        }
        return null;
    }

    /*Array Assignment Statemnt */
    /**
 * Grammar production:
 * f0 -> Identifier()
 * f1 -> "["
 * f2 -> Expression()
 * f3 -> "]"
 * f4 -> "="
 * f5 -> Expression()
 * f6 -> ";"
 */
    @Override
    public String visit(ArrayAssignmentStatement aas, Argu argu){
        String arrayType=aas.f0.accept(this,argu);
        String insideBracketType= aas.f2.accept(this,argu);
        String rightType=aas.f5.accept(this,argu);

        if(!(arrayType.equals("int[]") && insideBracketType.equals("int") && rightType.equals("int"))){
            throw new RuntimeException("Type error, arrays are always: int[int]=int");    
        }
        return null;
    }

    /*If Statemnet */
    /**
 * Grammar production:
 * f0 -> "if"
 * f1 -> "("
 * f2 -> Expression()
 * f3 -> ")"
 * f4 -> Statement()
 * f5 -> "else"
 * f6 -> Statement()
 */
    @Override
    public String visit(IfStatement is, Argu argu){
        String expr=is.f2.accept(this,argu);

        if(!expr.equals("boolean")){
            throw new RuntimeException("Type Error: if( "+expr+" ): expr must always be of type boolean");
        }
        is.f4.accept(this,argu);
        is.f6.accept(this,argu);
        return null;
    }

    /*While Statement */
    /**
 * Grammar production:
 * f0 -> "while"
 * f1 -> "("
 * f2 -> Expression()
 * f3 -> ")"
 * f4 -> Statement()
 */
    @Override 
    public String visit(WhileStatement ws, Argu argu){
        String expr=ws.f2.accept(this,argu);
        if(!expr.equals("boolean")){
            throw new RuntimeException("Type Error: while(" +expr+" ): expr must always be of type boolean");
        }
        ws.f4.accept(this,argu);
        return null;
    }

    /*Print Statement */
    /**
 * Grammar production:
 * f0 -> "System.out.println"
 * f1 -> "("
 * f2 -> Expression()
 * f3 -> ")"
 * f4 -> ";"
 */
    @Override
    public String visit(PrintStatement ps, Argu argu){
        String expr=ps.f2.accept(this,argu);
        if(!expr.equals("int")){
            throw new RuntimeException("Type Error: System.out.println( "+expr+" ): expr must always be of type int\n ");
        }
        return null;
    }



/*EXPRESSIONS*/
/*ARITHMETIC & COMPARISONS */

/**
 * Grammar production:
 * f0 -> PrimaryExpression()
 * f1 -> "+","-","*", "<", "&&"
 * f2 -> PrimaryExpression()
 */


/*Plus Expression */
    @Override
    public String visit(PlusExpression pe, Argu argu){
        
        String expr1=pe.f0.accept(this,argu);
        String expr2=pe.f2.accept(this,argu);
        if(expr1.equals("int") && expr2.equals("int")){
            return "int";
        }
        
        throw new RuntimeException("Type mismatch: operator expects int but got " + expr1);
    }

    /*Minus Expression */
    @Override
    public String visit(MinusExpression pe, Argu argu){
        
        String expr1=pe.f0.accept(this,argu);
        String expr2=pe.f2.accept(this,argu);
        if(expr1.equals("int") && expr2.equals("int")){
            return "int";
        }
        
        throw new RuntimeException("Type mismatch: operator expects int but got " + expr1);
    }

    /*Times Expression */
    @Override
    public String visit(TimesExpression te, Argu argu){
        
        String expr1=te.f0.accept(this,argu);
        String expr2=te.f2.accept(this,argu);
        if(expr1.equals("int") && expr2.equals("int")){
            return "int";
        }
        
        throw new RuntimeException("Type mismatch: operator expects int but got " + expr1);
    }

    /*Compare Expression */
    @Override
    public String visit(CompareExpression te, Argu argu){
        
        String expr1=te.f0.accept(this,argu);
        String expr2=te.f2.accept(this,argu);
        if(expr1.equals("int") && expr2.equals("int")){
            return "boolean";
        }
        
        throw new RuntimeException("Type mismatch: operator expects int but got " + expr1);
    }

    /*And Expression */
    @Override
    public String visit(AndExpression ae, Argu argu){
        String expr1=ae.f0.accept(this,argu);
        String expr2=ae.f2.accept(this,argu);
        if(expr1.equals("boolean") && expr2.equals("boolean")){
            return "boolean";
        }

        throw new RuntimeException("Type mismatch: operator expects boolean but got " + expr1);

    }

/* ARRAYS */

/*Array Lookup */
/**
 * Grammar production:
 * f0 -> PrimaryExpression()
 * f1 -> "["
 * f2 -> PrimaryExpression()
 * f3 -> "]"
 */
    @Override
    public String visit(ArrayLookup al, Argu argu){
        String expr1=al.f0.accept(this,argu);
        String expr2=al.f2.accept(this,argu);
        if(expr1.equals("int[]") && expr2.equals("int")){
            return "int";
        }
        throw new RuntimeException("Type error, arrays are always: int[int]");
    }

/*Array Lenght */
/**
 * Grammar production:
 * f0 -> PrimaryExpression()
 * f1 -> "."
 * f2 -> "length"
 */

    @Override
    public String visit(ArrayLength al, Argu argu){
        String expr=al.f0.accept(this,argu);
        if(expr.equals("int[]")){
            return "int";
        }
        throw new RuntimeException("Type error, arrays are always: int[]");
    }

 /*Array Allocation */
    /**
 * Grammar production:
 * f0 -> "new"
 * f1 -> "int"
 * f2 -> "["
 * f3 -> Expression()
 * f4 -> "]"
 */
    @Override
    public String visit(ArrayAllocationExpression aae, Argu argu){
        String expr=aae.f3.accept(this,argu);
        if(expr.equals("int")){
            return "int[]";
        }
        throw new RuntimeException("Type error, arrays are always: int[int]");
    }

    

/*Not expression */
/**
 * Grammar production:
 * f0 -> "!"
 * f1 -> PrimaryExpression()
 */
    @Override
    public String visit(NotExpression ne, Argu argu){
        String expr=ne.f1.accept(this,argu);
        if(expr.equals("boolean")){
            return "boolean";
        }
        throw new RuntimeException("Type error, expected boolean, instead got: "+expr);
    }

    /*bracket expression */
    /**
 * Grammar production:
 * f0 -> "("
 * f1 -> Expression()
 * f2 -> ")"
 */
    @Override
    public String visit(BracketExpression ne, Argu argu){
        String expr=ne.f1.accept(this,argu);
        return expr;
    }

    /*Allocatiion Expression */
/**
 * Grammar production:
 * f0 -> "new"
 * f1 -> Identifier()
 * f2 -> "("
 * f3 -> ")"
 */

    @Override
    public String visit(AllocationExpression ae, Argu argu){
        String id=ae.f1.f0.toString();
        if(symbolTable.containsKey(id)){
            return id;
        }
        throw new RuntimeException("Type error, no such type: "+id);
    }

/*Message Send Expression*/

    /**
 * Grammar production:
 * f0 -> PrimaryExpression()
 * f1 -> "."
 * f2 -> Identifier()
 * f3 -> "("
 * f4 -> ( ExpressionList() )?
 * f5 -> ")"
 */

    @Override
    public String visit(MessageSend ms, Argu argu){
        String objType=ms.f0.accept(this,argu);
        String methodName=ms.f2.f0.toString();
        

        if(symbolTable.containsKey(objType)){
            List<MethodInfo> methods=checkMethod(objType, methodName);
            if(methods!=null){
                Argu argu2=new Argu(argu.className,argu.methodName);
                ms.f4.accept(this,argu2);

                for(MethodInfo mInfo: methods){
                    if(argu2.argTypes.size()==mInfo.formalParams.size()){
                        Iterator<String> formalParamIt=mInfo.formalParams.values().iterator(); //it will be ordered cause we use linked hashmap
                        Iterator<String> argIt= argu2.argTypes.iterator();
                        boolean flag=true;
                        while(formalParamIt.hasNext() && argIt.hasNext()){
                            if(!checkType(argIt.next(),formalParamIt.next())){
                                flag=false;
                                break;
                            }
                        }
                        if(flag){
                            return mInfo.methodType;
                        }
                    }
                }
            }
        }
        
        throw new RuntimeException("Type error in message send: "+objType+"."+methodName+"( ExpressionList())?)");
    }

/*EXPRESSION LIST */
/**
 * Grammar production:
 * f0 -> Expression()
 * f1 -> ExpressionTail()
 */
//To put the parameters in the argTypes List
    @Override
    public String visit(ExpressionList el,Argu argu){
        argu.argTypes.add(el.f0.accept(this,argu));
        el.f1.accept(this,argu);
        return null;
    }

/*EXPRESSION TERM */
/**
 * Grammar production:
 * f0 -> ","
 * f1 -> Expression()
 */
    @Override
    public String visit(ExpressionTerm et,Argu argu){
        argu.argTypes.add(et.f1.accept(this, argu));
        return null;
    }



/*LITERALS */


/*Integer literal */
    @Override
    public String visit(IntegerLiteral il, Argu argu){
        return "int";
    }

/*TrueLiteral */
    @Override
    public String visit(TrueLiteral tl,Argu argu){
        return "boolean";
    }
    /*FalseLiteral */
    @Override
    public String visit(FalseLiteral tl,Argu argu){
        return "boolean";
    }

    /*This expression */
    @Override
    public String visit(ThisExpression tl,Argu argu){
        return argu.className;
    }


       /*TYPE */
        /**
         * Grammar production:
         * f0 -> ArrayType()
         *       | BooleanType()
         *       | IntegerType()
         *       | Identifier()
         */


    
    @Override
    public String visit(Type t, Argu argu){
        if(t.f0.choice instanceof Identifier){
            return ((Identifier)t.f0.choice).f0.toString();
        }
        return t.f0.accept(this, argu);
    }


    /*ARRAY TYPE */
    @Override 
    public String visit(ArrayType at, Argu argu){
        return "int[]";
    }

    
    /*BOOLEAN TYPE */
    @Override 
    public String visit(BooleanType bt, Argu argu){
        return "boolean";
    }

    
    /*INTEGER TYPE */
    @Override 
    public String visit(IntegerType it, Argu argu){
        return "int";
    }

        /*IDENTIFIER */
    /**
 * Grammar production:
 * f0 -> <IDENTIFIER>
 */


    

    //Returns the type of the identifier 
    // When called at class level context we just return the identifier name as a string.
    // visit(Identifier) is ONLY used for variable lookup when inside a method body.
    //If identifier wasnt declared it throws an exception
    //DO NOT USE TO GET IDENTIFIER NAME IN THIS VISITOR//
    @Override 
    public String visit(Identifier i, Argu argu){
        //class level
        if(argu == null || argu.methodName == null){
            return i.f0.toString();
        }


        //method level
        MethodInfo currentMethod = getCurrentMethod(argu.className, argu.methodName);

        //inside method scope
        if(currentMethod.vars.containsKey(i.f0.toString())){
            return currentMethod.vars.get(i.f0.toString());
        }

        //formal parameter
        if(currentMethod.formalParams.containsKey(i.f0.toString())){
            return currentMethod.formalParams.get(i.f0.toString());
        }

        //check class fields
        String current=argu.className;
        while(current!=null){
            if(symbolTable.get(current).vars.containsKey(i.f0.toString())){
                return symbolTable.get(current).vars.get(i.f0.toString());
            }        
            current=symbolTable.get(current).parent;
        }
        throw new RuntimeException("Identifier: "+i.f0.toString()+" not defined"); 
    }
}