io.github.danielnaczo.python3parser.visitors.basic

Interface Python3ASTVisitor<R,P>

All Known Implementing Classes:

AliasPrettyPrintVisitor, ComprehensionPrettyPrintVisitor, DecoratorPrettyPrintVisitor, ExceptHandlerPrettyPrintVisitor, ExpressionPrettyPrintVisitor, GenericUnsupportedASTVisitor, KeywordPrettyPrintVisitor, ModifierVisitor, ModulePrettyPrintVisitor, OperatorPrettyPrintVisitor, ParametersPrettyPrintVisitor, SlicePrettyPrintVisitor, StatementPrettyPrintVisitor, UnaryOpPrettyPrintVisitor, WithItemPrettyPrintVisitor

public interface Python3ASTVisitor<R,P>

Method Summary

Modifier and Type	Method and Description
R	visitAdd(Add add, P param)
R	visitAlias(Alias alias, P param)
R	visitAnd(And and, P param)
R	visitAnnAssign(AnnAssign annAssign, P param)
R	visitArgumentComp(ArgumentComp argumentComp, P param)
R	visitArguments(Arguments arguments, P param)
R	visitAssert(Assert assertElement, P param)
R	visitAssign(Assign assign, P param)
R	visitAST(AST ast, P param)
R	visitAsyncFor(AsyncFor asyncFor, P param)
R	visitAsyncFunctionDef(AsyncFunctionDef asyncFunctionDef, P param)
R	visitAsyncWith(AsyncWith asyncWith, P param)
R	visitAt(At at, P param)
R	visitAtom(Atom atom, P param)
R	visitAttribute(Attribute attribute, P param)
R	visitAugAssign(AugAssign augAssign, P param)
R	visitAwait(Await await, P param)
R	visitBinOp(BinOp binOp, P param)
R	visitBitAnd(BitAnd bitAnd, P param)
R	visitBitOr(BitOr bitOr, P param)
R	visitBitXor(BitXor bitXor, P param)
R	visitBody(Body body, P param)
R	visitBreak(Break breakElement, P param)
R	visitClassDef(ClassDef classDef, P param)
R	visitCmpop(Cmpop cmpop, P param)
R	visitComprehension(Comprehension comprehension, P param)
R	visitContinue(Continue continueElements, P param)
R	visitDecorator(Decorator decorator, P param)
R	visitDefaultParameter(DefaultParameter defaultParameter, P param)
R	visitDelete(Delete delete, P param)
R	visitDict(Dict dict, P param)
R	visitDictComp(DictComp dictComp, P param)
R	visitDiv(Div div, P param)
R	visitEllipsis(Ellipsis ellipsis, P param)
R	visitEq(Eq eq, P param)
R	visitExceptHandler(ExceptHandler exceptHandler, P param)
R	visitExpression(Expression expression, P param)
R	visitExpressionList(ExpressionsList expressionList, P param)
R	visitExpressionMod(ExpressionMod expressionMod, P param)
R	visitExtSlice(ExtSlice extSlice, P param)
R	visitFalse(False falseElement, P param)
R	visitFloorDiv(FloorDiv floorDiv, P param)
R	visitFor(For forElement, P param)
R	visitFunctionDef(FunctionDef functionDef, P param)
R	visitGenerator(Generator generator, P param)
R	visitGlobal(Global global, P param)
R	visitGt(Gt gt, P param)
R	visitGtE(GtE gte, P param)
R	visitIdentifier(Identifier identifier, P param)
R	visitIf(If ifElement, P param)
R	visitIfExpr(IfExpr ifExpr, P param)
R	visitImport(Import importElement, P param)
R	visitImportFrom(ImportFrom importFrom, P param)
R	visitIn(In in, P param)
R	visitIndex(Index index, P param)
R	visitInteractive(Interactive interactive, P param)
R	visitInvert(Invert invert, P param)
R	visitIs(Is is, P param)
R	visitIsNot(IsNot isNot, P param)
R	visitJoinedStr(JoinedStr joinedStr, P param)
R	visitKeyword(Keyword keyword, P param)
R	visitLambda(Lambda lambda, P param)
R	visitListComp(ListComp listComp, P param)
R	visitListExpr(ListExpr listExpr, P param)
R	visitLShift(LShift lShift, P param)
R	visitLt(Lt lt, P param)
R	visitLtE(LtE lte, P param)
R	visitMod(Mod mod, P param)
R	visitModule(Module module, P param)
R	visitModulo(Mod modulo, P param)
R	visitMult(Mult mult, P param)
R	visitName(Name name, P param)
R	visitNone(None none, P param)
R	visitNonlocal(Nonlocal nonlocal, P param)
R	visitNot(Not not, P param)
R	visitNotEq(NotEq notEq, P param)
R	visitNotIn(NotIn notIn, P param)
R	visitNum(Num num, P param)
R	visitOperator(Operator operator, P param)
R	visitOr(Or or, P param)
R	visitParameter(Parameter parameter, P param)
R	visitParameters(Parameters parameters, P param)
R	visitPass(Pass pass, P param)
R	visitPow(Pow pow, P param)
R	visitRaise(Raise raise, P param)
R	visitReturn(Return returnElement, P param)
R	visitRShift(RShift rShift, P param)
R	visitSet(Set set, P param)
R	visitSetComp(SetComp setComp, P param)
R	visitSlice(Slice slice, P param)
R	visitSliceAbstract(SliceAbstract sliceAbstract, P param)
R	visitStarred(Starred starred, P param)
R	visitStatement(Statement statement, P param)
R	visitStr(Str arg, P param)
R	visitSub(Sub sub, P param)
R	visitSubscript(Subscript subscript, P param)
R	visitTrue(True trueElement, P param)
R	visitTry(Try tryElement, P param)
R	visitTuple(Tuple tuple, P param)
R	visitUAdd(UAdd uAdd, P param)
R	visitUnaryOp(UnaryOp unaryOp, P param)
R	visitUSub(USub uSub, P param)
R	visitWhile(While whileElement, P param)
R	visitWith(With with, P param)
R	visitWithItem(WithItem withItem, P param)
R	visitYield(Yield yield, P param)
R	visitYieldFrom(YieldFrom yieldFrom, P param)

Method Detail

visitParameter

R visitParameter(Parameter parameter,
                 P param)

visitParameters

R visitParameters(Parameters parameters,
                  P param)

visitAwait

R visitAwait(Await await,
             P param)

visitDefaultParameter

R visitDefaultParameter(DefaultParameter defaultParameter,
                        P param)

visitAnd

R visitAnd(And and,
           P param)

visitOr

R visitOr(Or or,
          P param)

visitCmpop

R visitCmpop(Cmpop cmpop,
             P param)

visitEq

R visitEq(Eq eq,
          P param)

visitGt

R visitGt(Gt gt,
          P param)

visitGtE

R visitGtE(GtE gte,
           P param)

visitIn

R visitIn(In in,
          P param)

visitIs

R visitIs(Is is,
          P param)

visitIsNot

R visitIsNot(IsNot isNot,
             P param)

visitLt

R visitLt(Lt lt,
          P param)

visitLtE

R visitLtE(LtE lte,
           P param)

visitNotEq

R visitNotEq(NotEq notEq,
             P param)

visitNotIn

R visitNotIn(NotIn notIn,
             P param)

visitArguments

R visitArguments(Arguments arguments,
                 P param)

visitArgumentComp

R visitArgumentComp(ArgumentComp argumentComp,
                    P param)

visitAtom

R visitAtom(Atom atom,
            P param)

visitAttribute

R visitAttribute(Attribute attribute,
                 P param)

visitBinOp

R visitBinOp(BinOp binOp,
             P param)

visitDecorator

R visitDecorator(Decorator decorator,
                 P param)

visitDict

R visitDict(Dict dict,
            P param)

visitDictComp

R visitDictComp(DictComp dictComp,
                P param)

visitEllipsis

R visitEllipsis(Ellipsis ellipsis,
                P param)

visitExpression

R visitExpression(Expression expression,
                  P param)

visitExpressionList

R visitExpressionList(ExpressionsList expressionList,
                      P param)

visitFalse

R visitFalse(False falseElement,
             P param)

visitIfExpr

R visitIfExpr(IfExpr ifExpr,
              P param)

visitJoinedStr

R visitJoinedStr(JoinedStr joinedStr,
                 P param)

visitLambda

R visitLambda(Lambda lambda,
              P param)

visitListComp

R visitListComp(ListComp listComp,
                P param)

visitListExpr

R visitListExpr(ListExpr listExpr,
                P param)

visitName

R visitName(Name name,
            P param)

visitNone

R visitNone(None none,
            P param)

visitNum

R visitNum(Num num,
           P param)

visitSet

R visitSet(Set set,
           P param)

visitSetComp

R visitSetComp(SetComp setComp,
               P param)

visitStarred

R visitStarred(Starred starred,
               P param)

visitStr

R visitStr(Str arg,
           P param)

visitSubscript

R visitSubscript(Subscript subscript,
                 P param)

visitTrue

R visitTrue(True trueElement,
            P param)

visitTuple

R visitTuple(Tuple tuple,
             P param)

visitGenerator

R visitGenerator(Generator generator,
                 P param)

visitUnaryOp

R visitUnaryOp(UnaryOp unaryOp,
               P param)

visitYield

R visitYield(Yield yield,
             P param)

visitYieldFrom

R visitYieldFrom(YieldFrom yieldFrom,
                 P param)

visitExpressionMod

R visitExpressionMod(ExpressionMod expressionMod,
                     P param)

visitInteractive

R visitInteractive(Interactive interactive,
                   P param)

visitMod

R visitMod(Mod mod,
           P param)

visitModule

R visitModule(Module module,
              P param)

visitAdd

R visitAdd(Add add,
           P param)

visitAt

R visitAt(At at,
          P param)

visitBitAnd

R visitBitAnd(BitAnd bitAnd,
              P param)

visitBitOr

R visitBitOr(BitOr bitOr,
             P param)

visitBitXor

R visitBitXor(BitXor bitXor,
              P param)

visitDiv

R visitDiv(Div div,
           P param)

visitFloorDiv

R visitFloorDiv(FloorDiv floorDiv,
                P param)

visitLShift

R visitLShift(LShift lShift,
              P param)

visitModulo

R visitModulo(Mod modulo,
              P param)

visitMult

R visitMult(Mult mult,
            P param)

visitOperator

R visitOperator(Operator operator,
                P param)

visitPow

R visitPow(Pow pow,
           P param)

visitRShift

R visitRShift(RShift rShift,
              P param)

visitSub

R visitSub(Sub sub,
           P param)

visitExtSlice

R visitExtSlice(ExtSlice extSlice,
                P param)

visitIndex

R visitIndex(Index index,
             P param)

visitSlice

R visitSlice(Slice slice,
             P param)

visitSliceAbstract

R visitSliceAbstract(SliceAbstract sliceAbstract,
                     P param)

visitAnnAssign

R visitAnnAssign(AnnAssign annAssign,
                 P param)

visitAssert

R visitAssert(Assert assertElement,
              P param)

visitAssign

R visitAssign(Assign assign,
              P param)

visitAsyncFor

R visitAsyncFor(AsyncFor asyncFor,
                P param)

visitAsyncFunctionDef

R visitAsyncFunctionDef(AsyncFunctionDef asyncFunctionDef,
                        P param)

visitAsyncWith

R visitAsyncWith(AsyncWith asyncWith,
                 P param)

visitAugAssign

R visitAugAssign(AugAssign augAssign,
                 P param)

visitBody

R visitBody(Body body,
            P param)

visitBreak

R visitBreak(Break breakElement,
             P param)

visitClassDef

R visitClassDef(ClassDef classDef,
                P param)

visitContinue

R visitContinue(Continue continueElements,
                P param)

visitDelete

R visitDelete(Delete delete,
              P param)

visitFor

R visitFor(For forElement,
           P param)

visitFunctionDef

R visitFunctionDef(FunctionDef functionDef,
                   P param)

visitGlobal

R visitGlobal(Global global,
              P param)

visitIf

R visitIf(If ifElement,
          P param)

visitImport

R visitImport(Import importElement,
              P param)

visitImportFrom

R visitImportFrom(ImportFrom importFrom,
                  P param)

visitNonlocal

R visitNonlocal(Nonlocal nonlocal,
                P param)

visitPass

R visitPass(Pass pass,
            P param)

visitRaise

R visitRaise(Raise raise,
             P param)

visitReturn

R visitReturn(Return returnElement,
              P param)

visitStatement

R visitStatement(Statement statement,
                 P param)

visitTry

R visitTry(Try tryElement,
           P param)

visitWhile

R visitWhile(While whileElement,
             P param)

visitWith

R visitWith(With with,
            P param)

visitInvert

R visitInvert(Invert invert,
              P param)

visitNot

R visitNot(Not not,
           P param)

visitUAdd

R visitUAdd(UAdd uAdd,
            P param)

visitUSub

R visitUSub(USub uSub,
            P param)

visitAlias

R visitAlias(Alias alias,
             P param)

visitAST

R visitAST(AST ast,
           P param)

visitComprehension

R visitComprehension(Comprehension comprehension,
                     P param)

visitExceptHandler

R visitExceptHandler(ExceptHandler exceptHandler,
                     P param)

visitIdentifier

R visitIdentifier(Identifier identifier,
                  P param)

visitKeyword

R visitKeyword(Keyword keyword,
               P param)

visitWithItem

R visitWithItem(WithItem withItem,
                P param)