//generated by abstract-syntax-gen
package de.peeeq.wurstscript.jassIm;
import java.util.*;

public interface Element {
    Element getParent();
    Element copy();
    Element copyWithRefs();
    int size();
    void clearAttributes();
    void clearAttributesLocal();
    Element get(int i);
    Element set(int i, Element newElement);
    void forEachElement(java.util.function.Consumer<? super Element> action);
    default void trimToSize() {        forEachElement(Element::trimToSize);    }    void setParent(Element parent);
    void replaceBy(Element other);
    boolean structuralEquals(Element elem);
    default List<Integer> pathTo(Element  elem) {
        List<Integer> path = new ArrayList<>();
        while (elem != this) {
            if (elem == null) {
                throw new RuntimeException("Element " + elem + " is not a parent of " + this);
            }
            Element parent = elem.getParent();
            for (int i = 0; i < parent.size(); i++) {
                if (parent.get(i) == elem) {
                    path.add(i);
                    break;
                }
            }
            elem = parent;
        }
        Collections.reverse(path);
        return path;
    }

    default Element followPath(Iterable<Integer> path) {
        Element elem = this;
        for (Integer i : path) {
            elem = elem.get(i);
        }
        return elem;
    }
    <T> T match(Matcher<T> s);
    void match(MatcherVoid s);
    public interface Matcher<T> {
        T case_ImClass(ImClass imClass);
        T case_ImVarArrayAccess(ImVarArrayAccess imVarArrayAccess);
        T case_ImTypeIdOfClass(ImTypeIdOfClass imTypeIdOfClass);
        T case_ImClassType(ImClassType imClassType);
        T case_ImTypeClassFuncs(ImTypeClassFuncs imTypeClassFuncs);
        T case_ImTupleType(ImTupleType imTupleType);
        T case_ImInstanceof(ImInstanceof imInstanceof);
        T case_ImSet(ImSet imSet);
        T case_ImTypeIdOfObj(ImTypeIdOfObj imTypeIdOfObj);
        T case_ImVarargLoop(ImVarargLoop imVarargLoop);
        T case_ImVars(ImVars imVars);
        T case_ImVar(ImVar imVar);
        T case_ImFunctions(ImFunctions imFunctions);
        T case_ImTupleSelection(ImTupleSelection imTupleSelection);
        T case_ImClasses(ImClasses imClasses);
        T case_ImMemberAccess(ImMemberAccess imMemberAccess);
        T case_ImIf(ImIf imIf);
        T case_ImRealVal(ImRealVal imRealVal);
        T case_ImNull(ImNull imNull);
        T case_ImVoid(ImVoid imVoid);
        T case_ImReturn(ImReturn imReturn);
        T case_ImFuncRef(ImFuncRef imFuncRef);
        T case_ImTypeVarRef(ImTypeVarRef imTypeVarRef);
        T case_ImArrayTypeMulti(ImArrayTypeMulti imArrayTypeMulti);
        T case_ImDealloc(ImDealloc imDealloc);
        T case_ImFunctionCall(ImFunctionCall imFunctionCall);
        T case_ImMethodCall(ImMethodCall imMethodCall);
        T case_ImOperatorCall(ImOperatorCall imOperatorCall);
        T case_ImExitwhen(ImExitwhen imExitwhen);
        T case_ImSimpleType(ImSimpleType imSimpleType);
        T case_ImMethod(ImMethod imMethod);
        T case_ImVarAccess(ImVarAccess imVarAccess);
        T case_ImBoolVal(ImBoolVal imBoolVal);
        T case_ImTypeArguments(ImTypeArguments imTypeArguments);
        T case_ImMethods(ImMethods imMethods);
        T case_ImArrayType(ImArrayType imArrayType);
        T case_ImGetStackTrace(ImGetStackTrace imGetStackTrace);
        T case_ImExprs(ImExprs imExprs);
        T case_ImLoop(ImLoop imLoop);
        T case_ImNoExpr(ImNoExpr imNoExpr);
        T case_ImTypeArgument(ImTypeArgument imTypeArgument);
        T case_ImTypeVar(ImTypeVar imTypeVar);
        T case_ImAlloc(ImAlloc imAlloc);
        T case_ImStringVal(ImStringVal imStringVal);
        T case_ImCompiletimeExpr(ImCompiletimeExpr imCompiletimeExpr);
        T case_ImTupleExpr(ImTupleExpr imTupleExpr);
        T case_ImTypeVarDispatch(ImTypeVarDispatch imTypeVarDispatch);
        T case_ImTypeVars(ImTypeVars imTypeVars);
        T case_ImProg(ImProg imProg);
        T case_ImStmts(ImStmts imStmts);
        T case_ImCast(ImCast imCast);
        T case_ImAnyType(ImAnyType imAnyType);
        T case_ImTypeClassFunc(ImTypeClassFunc imTypeClassFunc);
        T case_ImStatementExpr(ImStatementExpr imStatementExpr);
        T case_ImFunction(ImFunction imFunction);
        T case_ImIntVal(ImIntVal imIntVal);
    }

    public interface MatcherVoid {
        void case_ImClass(ImClass imClass);
        void case_ImVarArrayAccess(ImVarArrayAccess imVarArrayAccess);
        void case_ImTypeIdOfClass(ImTypeIdOfClass imTypeIdOfClass);
        void case_ImClassType(ImClassType imClassType);
        void case_ImTypeClassFuncs(ImTypeClassFuncs imTypeClassFuncs);
        void case_ImTupleType(ImTupleType imTupleType);
        void case_ImInstanceof(ImInstanceof imInstanceof);
        void case_ImSet(ImSet imSet);
        void case_ImTypeIdOfObj(ImTypeIdOfObj imTypeIdOfObj);
        void case_ImVarargLoop(ImVarargLoop imVarargLoop);
        void case_ImVars(ImVars imVars);
        void case_ImVar(ImVar imVar);
        void case_ImFunctions(ImFunctions imFunctions);
        void case_ImTupleSelection(ImTupleSelection imTupleSelection);
        void case_ImClasses(ImClasses imClasses);
        void case_ImMemberAccess(ImMemberAccess imMemberAccess);
        void case_ImIf(ImIf imIf);
        void case_ImRealVal(ImRealVal imRealVal);
        void case_ImNull(ImNull imNull);
        void case_ImVoid(ImVoid imVoid);
        void case_ImReturn(ImReturn imReturn);
        void case_ImFuncRef(ImFuncRef imFuncRef);
        void case_ImTypeVarRef(ImTypeVarRef imTypeVarRef);
        void case_ImArrayTypeMulti(ImArrayTypeMulti imArrayTypeMulti);
        void case_ImDealloc(ImDealloc imDealloc);
        void case_ImFunctionCall(ImFunctionCall imFunctionCall);
        void case_ImMethodCall(ImMethodCall imMethodCall);
        void case_ImOperatorCall(ImOperatorCall imOperatorCall);
        void case_ImExitwhen(ImExitwhen imExitwhen);
        void case_ImSimpleType(ImSimpleType imSimpleType);
        void case_ImMethod(ImMethod imMethod);
        void case_ImVarAccess(ImVarAccess imVarAccess);
        void case_ImBoolVal(ImBoolVal imBoolVal);
        void case_ImTypeArguments(ImTypeArguments imTypeArguments);
        void case_ImMethods(ImMethods imMethods);
        void case_ImArrayType(ImArrayType imArrayType);
        void case_ImGetStackTrace(ImGetStackTrace imGetStackTrace);
        void case_ImExprs(ImExprs imExprs);
        void case_ImLoop(ImLoop imLoop);
        void case_ImNoExpr(ImNoExpr imNoExpr);
        void case_ImTypeArgument(ImTypeArgument imTypeArgument);
        void case_ImTypeVar(ImTypeVar imTypeVar);
        void case_ImAlloc(ImAlloc imAlloc);
        void case_ImStringVal(ImStringVal imStringVal);
        void case_ImCompiletimeExpr(ImCompiletimeExpr imCompiletimeExpr);
        void case_ImTupleExpr(ImTupleExpr imTupleExpr);
        void case_ImTypeVarDispatch(ImTypeVarDispatch imTypeVarDispatch);
        void case_ImTypeVars(ImTypeVars imTypeVars);
        void case_ImProg(ImProg imProg);
        void case_ImStmts(ImStmts imStmts);
        void case_ImCast(ImCast imCast);
        void case_ImAnyType(ImAnyType imAnyType);
        void case_ImTypeClassFunc(ImTypeClassFunc imTypeClassFunc);
        void case_ImStatementExpr(ImStatementExpr imStatementExpr);
        void case_ImFunction(ImFunction imFunction);
        void case_ImIntVal(ImIntVal imIntVal);
    }

    public abstract void accept(Visitor v);
    public interface Visitor {
        void visit(ImProg imProg);
        void visit(ImVar imVar);
        void visit(ImSimpleType imSimpleType);
        void visit(ImTupleType imTupleType);
        void visit(ImVoid imVoid);
        void visit(ImClassType imClassType);
        void visit(ImTypeVarRef imTypeVarRef);
        void visit(ImAnyType imAnyType);
        void visit(ImArrayType imArrayType);
        void visit(ImArrayTypeMulti imArrayTypeMulti);
        void visit(ImTypeVar imTypeVar);
        void visit(ImFunction imFunction);
        void visit(ImTypeClassFunc imTypeClassFunc);
        void visit(ImClass imClass);
        void visit(ImMethod imMethod);
        void visit(ImIf imIf);
        void visit(ImLoop imLoop);
        void visit(ImExitwhen imExitwhen);
        void visit(ImReturn imReturn);
        void visit(ImSet imSet);
        void visit(ImVarargLoop imVarargLoop);
        void visit(ImNoExpr imNoExpr);
        void visit(ImGetStackTrace imGetStackTrace);
        void visit(ImCompiletimeExpr imCompiletimeExpr);
        void visit(ImTypeVarDispatch imTypeVarDispatch);
        void visit(ImCast imCast);
        void visit(ImVarAccess imVarAccess);
        void visit(ImVarArrayAccess imVarArrayAccess);
        void visit(ImTupleSelection imTupleSelection);
        void visit(ImTupleExpr imTupleExpr);
        void visit(ImStatementExpr imStatementExpr);
        void visit(ImMethodCall imMethodCall);
        void visit(ImMemberAccess imMemberAccess);
        void visit(ImAlloc imAlloc);
        void visit(ImDealloc imDealloc);
        void visit(ImInstanceof imInstanceof);
        void visit(ImTypeIdOfObj imTypeIdOfObj);
        void visit(ImTypeIdOfClass imTypeIdOfClass);
        void visit(ImFunctionCall imFunctionCall);
        void visit(ImOperatorCall imOperatorCall);
        void visit(ImIntVal imIntVal);
        void visit(ImRealVal imRealVal);
        void visit(ImStringVal imStringVal);
        void visit(ImBoolVal imBoolVal);
        void visit(ImFuncRef imFuncRef);
        void visit(ImNull imNull);
        void visit(ImTypeArgument imTypeArgument);
        void visit(ImVars imVars);
        void visit(ImFunctions imFunctions);
        void visit(ImClasses imClasses);
        void visit(ImTypeClassFuncs imTypeClassFuncs);
        void visit(ImTypeVars imTypeVars);
        void visit(ImMethods imMethods);
        void visit(ImStmts imStmts);
        void visit(ImExprs imExprs);
        void visit(ImTypeArguments imTypeArguments);
    }
    public static abstract class DefaultVisitor implements Visitor {
        @Override public void visit(ImProg imProg) {
          imProg.getGlobals().accept(this);
          imProg.getFunctions().accept(this);
          imProg.getMethods().accept(this);
          imProg.getClasses().accept(this);
          imProg.getTypeClassFunctions().accept(this);
     }
        @Override public void visit(ImVar imVar) {
     }
        @Override public void visit(ImSimpleType imSimpleType) {
     }
        @Override public void visit(ImTupleType imTupleType) {
     }
        @Override public void visit(ImVoid imVoid) {
     }
        @Override public void visit(ImClassType imClassType) {
          imClassType.getTypeArguments().accept(this);
     }
        @Override public void visit(ImTypeVarRef imTypeVarRef) {
     }
        @Override public void visit(ImAnyType imAnyType) {
     }
        @Override public void visit(ImArrayType imArrayType) {
     }
        @Override public void visit(ImArrayTypeMulti imArrayTypeMulti) {
     }
        @Override public void visit(ImTypeVar imTypeVar) {
     }
        @Override public void visit(ImFunction imFunction) {
          imFunction.getTypeVariables().accept(this);
          imFunction.getParameters().accept(this);
          imFunction.getLocals().accept(this);
          imFunction.getBody().accept(this);
     }
        @Override public void visit(ImTypeClassFunc imTypeClassFunc) {
          imTypeClassFunc.getTypeVariables().accept(this);
          imTypeClassFunc.getParameters().accept(this);
     }
        @Override public void visit(ImClass imClass) {
          imClass.getTypeVariables().accept(this);
          imClass.getFields().accept(this);
          imClass.getMethods().accept(this);
          imClass.getFunctions().accept(this);
     }
        @Override public void visit(ImMethod imMethod) {
     }
        @Override public void visit(ImIf imIf) {
          imIf.getCondition().accept(this);
          imIf.getThenBlock().accept(this);
          imIf.getElseBlock().accept(this);
     }
        @Override public void visit(ImLoop imLoop) {
          imLoop.getBody().accept(this);
     }
        @Override public void visit(ImExitwhen imExitwhen) {
          imExitwhen.getCondition().accept(this);
     }
        @Override public void visit(ImReturn imReturn) {
          imReturn.getReturnValue().accept(this);
     }
        @Override public void visit(ImSet imSet) {
          imSet.getLeft().accept(this);
          imSet.getRight().accept(this);
     }
        @Override public void visit(ImVarargLoop imVarargLoop) {
          imVarargLoop.getBody().accept(this);
     }
        @Override public void visit(ImNoExpr imNoExpr) {
     }
        @Override public void visit(ImGetStackTrace imGetStackTrace) {
     }
        @Override public void visit(ImCompiletimeExpr imCompiletimeExpr) {
          imCompiletimeExpr.getExpr().accept(this);
     }
        @Override public void visit(ImTypeVarDispatch imTypeVarDispatch) {
          imTypeVarDispatch.getArguments().accept(this);
     }
        @Override public void visit(ImCast imCast) {
          imCast.getExpr().accept(this);
     }
        @Override public void visit(ImVarAccess imVarAccess) {
     }
        @Override public void visit(ImVarArrayAccess imVarArrayAccess) {
          imVarArrayAccess.getIndexes().accept(this);
     }
        @Override public void visit(ImTupleSelection imTupleSelection) {
          imTupleSelection.getTupleExpr().accept(this);
     }
        @Override public void visit(ImTupleExpr imTupleExpr) {
          imTupleExpr.getExprs().accept(this);
     }
        @Override public void visit(ImStatementExpr imStatementExpr) {
          imStatementExpr.getStatements().accept(this);
          imStatementExpr.getExpr().accept(this);
     }
        @Override public void visit(ImMethodCall imMethodCall) {
          imMethodCall.getTypeArguments().accept(this);
          imMethodCall.getReceiver().accept(this);
          imMethodCall.getArguments().accept(this);
     }
        @Override public void visit(ImMemberAccess imMemberAccess) {
          imMemberAccess.getReceiver().accept(this);
          imMemberAccess.getTypeArguments().accept(this);
          imMemberAccess.getIndexes().accept(this);
     }
        @Override public void visit(ImAlloc imAlloc) {
     }
        @Override public void visit(ImDealloc imDealloc) {
          imDealloc.getObj().accept(this);
     }
        @Override public void visit(ImInstanceof imInstanceof) {
          imInstanceof.getObj().accept(this);
     }
        @Override public void visit(ImTypeIdOfObj imTypeIdOfObj) {
          imTypeIdOfObj.getObj().accept(this);
     }
        @Override public void visit(ImTypeIdOfClass imTypeIdOfClass) {
     }
        @Override public void visit(ImFunctionCall imFunctionCall) {
          imFunctionCall.getTypeArguments().accept(this);
          imFunctionCall.getArguments().accept(this);
     }
        @Override public void visit(ImOperatorCall imOperatorCall) {
          imOperatorCall.getArguments().accept(this);
     }
        @Override public void visit(ImIntVal imIntVal) {
     }
        @Override public void visit(ImRealVal imRealVal) {
     }
        @Override public void visit(ImStringVal imStringVal) {
     }
        @Override public void visit(ImBoolVal imBoolVal) {
     }
        @Override public void visit(ImFuncRef imFuncRef) {
     }
        @Override public void visit(ImNull imNull) {
     }
        @Override public void visit(ImTypeArgument imTypeArgument) {
     }
        @Override public void visit(ImVars imVars) {
          for (ImVar i : imVars ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImFunctions imFunctions) {
          for (ImFunction i : imFunctions ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImClasses imClasses) {
          for (ImClass i : imClasses ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImTypeClassFuncs imTypeClassFuncs) {
          for (ImTypeClassFunc i : imTypeClassFuncs ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImTypeVars imTypeVars) {
          for (ImTypeVar i : imTypeVars ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImMethods imMethods) {
          for (ImMethod i : imMethods ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImStmts imStmts) {
          for (ImStmt i : imStmts ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImExprs imExprs) {
          for (ImExpr i : imExprs ) {
              i.accept(this);
          }
     }
        @Override public void visit(ImTypeArguments imTypeArguments) {
          for (ImTypeArgument i : imTypeArguments ) {
              i.accept(this);
          }
     }
    }
    /** */
    public abstract String toString();
    /** */
    public abstract ImFunction getNearestFunc();
    /** */
    public abstract de.peeeq.wurstscript.ast.Element attrTrace();
    /** */
    public abstract ImProg attrProg();
}