Package io.github.danielnaczo.python3parser.visitors.basic

Interface Python3ASTVisitor<R,​P>

    • 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)