JavaTXCompilerInJavaTX/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java

package de.dhbwstuttgart.syntaxtree.statement;

import de.dhbwstuttgart.exceptions.TypeinferenceException;
import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
import de.dhbwstuttgart.typeinference.constraints.Constraint;
import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
import de.dhbwstuttgart.typeinference.constraints.ConstraintsFactory;
import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
import de.dhbwstuttgart.typeinference.constraints.Pair;
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
import org.antlr.v4.runtime.Token;

import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;

import java.util.*;


public class MethodCall extends Statement
{
    private final String name;
    private Receiver receiver;
    private ArgumentList arglist;

    public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, Token offset){
		super(retType,offset);
		this.arglist = argumentList;
        this.name = methodName;
        this.receiver = receiver;
	}

    @Override
    public ConstraintSet getConstraints(TypeInferenceBlockInformation info) {
        ConstraintSet ret = receiver.getConstraints(info);
        ret.addAll(this.getArgumentListConstraints(info));
        //Overloading:
        Set<Constraint> methodConstraints = new HashSet<>();
        for(MethodAssumption m : this.getMethods(name, arglist, info)){
            methodConstraints.add(generateConstraint(m, info));
        }
        if(methodConstraints.size()<1){
            throw new TypeinferenceException("Methode "+name+" ist nicht vorhanden!",getOffset());
        }
        ret.addOderConstraint(methodConstraints);
        return ret;
    }

    protected Constraint<Pair> generateConstraint(MethodAssumption forMethod, TypeInferenceBlockInformation info){
        Constraint methodConstraint = new Constraint();
        methodConstraint.add(ConstraintsFactory.createPair(receiver.getType(), forMethod.getReceiverType(), PairOperator.SMALLERDOT, info));
        methodConstraint.add(ConstraintsFactory.createPair(forMethod.getReturnType(), this.getType(), PairOperator.SMALLERDOT, info));
        methodConstraint.addAll(generateParameterConstraints(forMethod, info));
        return methodConstraint;
    }

    protected Set<Pair> generateParameterConstraints(MethodAssumption forMethod, TypeInferenceBlockInformation info) {
        Set<Pair> ret = new HashSet<>();
        for(int i = 0;i<arglist.getArguments().size();i++){
            ret.add(ConstraintsFactory.createPair(forMethod.getArgTypes().get(i),
                    arglist.getArguments().get(i).getType(), PairOperator.SMALLERDOT, info));
        }
        return ret;
    }


    public List<MethodAssumption> getMethods(String name, ArgumentList arglist, TypeInferenceBlockInformation info) {
        List<MethodAssumption> ret = new ArrayList<>();
        for(ClassOrInterface cl : info.getAvailableClasses()){
            for(Method m : cl.getMethods()){
                if(m.getName().equals(name) &&
                        m.getParameterList().getFormalparalist().size() == arglist.getArguments().size()){
                    RefTypeOrTPHOrWildcardOrGeneric retType = info.checkGTV(m.getType());

                    ret.add(new MethodAssumption(cl.getType(), retType, convertParams(m.getParameterList(),info)));
                }
            }
        }
        return ret;
    }

    protected List<RefTypeOrTPHOrWildcardOrGeneric> convertParams(ParameterList parameterList, TypeInferenceBlockInformation info){
        List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
        for(FormalParameter fp : parameterList.getFormalparalist()){
            params.add(info.checkGTV(fp.getType()));
        }
        return params;
    }

    public ArgumentList getArgumentList() {
        return arglist;
    }

    public ConstraintSet getArgumentListConstraints(TypeInferenceBlockInformation info) {
        ConstraintSet ret = new ConstraintSet();
        for(int i = 0;i<arglist.getArguments().size();i++){
            ret.addAll(arglist.getArguments().get(i).getConstraints(info));
        }
        return ret;
    }
}