package chocopy.common.analysis;

import chocopy.common.astnodes.*;

/**
 * This interface can be used to separate logic for various concrete
 * classes in the AST class hierarchy.
 * <p>
 * The idea is that a phase of the analysis is encapsulated in a class
 * that implements this interface, and contains an overriding of the
 * analyze method for each concrete Node class that needs something
 * other than default processing.  Each concrete node class, C, implements
 * a generic dispatch method that takes a NodeAnalyzer<T> argument and
 * calls the overloading of analyze that takes an argument of type C.
 * The effect is that anode.dispatch(anAnalyzer) executes the method
 * anAnalyzer.analyze that is appropriate to aNode's dynamic type.
 * As a result each NodeAnalyzer subtype encapsulates all
 * implementations of a particular action on Nodes.  Thus, it inverts
 * the usual OO pattern in which the implementations of analysis A for
 * each different class are scattered among the class bodies
 * themselves as overridings of a method A on the Node class.
 * <p>
 * The class AbstractNodeAnalyzer provides empty default
 * implementations for these methods.
 * <p>
 * The type T is the type of result returned by the encapsulated analysis.
 */
public interface NodeAnalyzer<T> {

    T analyze(AssignStmt node);

    T analyze(BinaryExpr node);

    T analyze(BooleanLiteral node);

    T analyze(CallExpr node);

    T analyze(ClassDef node);

    T analyze(ClassType node);

    T analyze(CompilerError node);

    T analyze(Errors node);

    T analyze(ExprStmt node);

    T analyze(ForStmt node);

    T analyze(FuncDef node);

    T analyze(GlobalDecl node);

    T analyze(Identifier node);

    T analyze(IfExpr node);

    T analyze(IfStmt node);

    T analyze(IndexExpr node);

    T analyze(IntegerLiteral node);

    T analyze(ListExpr node);

    T analyze(ListType node);

    T analyze(MemberExpr node);

    T analyze(MethodCallExpr node);

    T analyze(NoneLiteral node);

    T analyze(NonLocalDecl node);

    T analyze(Program node);

    T analyze(ReturnStmt node);

    T analyze(StringLiteral node);

    T analyze(TypedVar node);

    T analyze(UnaryExpr node);

    T analyze(VarDef node);

    T analyze(WhileStmt node);

    /**
     * Set the default value returned by calls to analyze that are not
     * overridden to VALUE. By default, this is null.
     */
    void setDefault(T value);

    /**
     * Default value for non-overridden methods.
     */
    T defaultAction(Node node);
}