public override async Task WalkAsync(PythonWalkerAsync walker, CancellationToken cancellationToken = default)
        {
            if (await walker.WalkAsync(this, cancellationToken))
            {
                if (NameExpression != null)
                {
                    await NameExpression.WalkAsync(walker, cancellationToken);
                }

                foreach (var p in Parameters)
                {
                    await p.WalkAsync(walker, cancellationToken);
                }

                if (Decorators != null)
                {
                    await Decorators.WalkAsync(walker, cancellationToken);
                }
                if (_body != null)
                {
                    await _body.WalkAsync(walker, cancellationToken);
                }
                if (ReturnAnnotation != null)
                {
                    await ReturnAnnotation.WalkAsync(walker, cancellationToken);
                }
            }
            await walker.PostWalkAsync(this, cancellationToken);
        }
 public override void Walk(PythonWalker walker)
 {
     if (walker.Walk(this))
     {
         NameExpression?.Walk(walker);
         foreach (var p in Parameters)
         {
             p.Walk(walker);
         }
         Decorators?.Walk(walker);
         _body?.Walk(walker);
         ReturnAnnotation?.Walk(walker);
     }
     walker.PostWalk(this);
 }
 public override void Walk(PythonWalker walker)
 {
     if (walker.Walk(this))
     {
         if (_parameters != null)
         {
             foreach (Parameter p in _parameters)
             {
                 p.Walk(walker);
             }
         }
         if (Decorators != null)
         {
             foreach (Expression decorator in Decorators)
             {
                 decorator.Walk(walker);
             }
         }
         ReturnAnnotation?.Walk(walker);
         Body?.Walk(walker);
     }
     walker.PostWalk(this);
 }
        internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
        {
            Decorators?.AppendCodeString(res, ast, format);

            format.ReflowComment(res, this.GetPreceedingWhiteSpaceDefaultNull(ast));

            if (IsCoroutine)
            {
                res.Append("async");
                res.Append(NodeAttributes.GetWhiteSpace(this, ast, WhitespaceAfterAsync));
            }

            res.Append("def");
            var name = this.GetVerbatimImage(ast) ?? Name;

            if (!string.IsNullOrEmpty(name))
            {
                res.Append(this.GetSecondWhiteSpace(ast));
                res.Append(name);
                if (!this.IsIncompleteNode(ast))
                {
                    format.Append(
                        res,
                        format.SpaceBeforeFunctionDeclarationParen,
                        " ",
                        "",
                        this.GetThirdWhiteSpaceDefaultNull(ast)
                        );

                    res.Append('(');
                    if (Parameters.Length != 0)
                    {
                        var commaWhiteSpace = this.GetListWhiteSpace(ast);
                        ParamsToString(res,
                                       ast,
                                       commaWhiteSpace,
                                       format,
                                       format.SpaceWithinFunctionDeclarationParens != null ?
                                       format.SpaceWithinFunctionDeclarationParens.Value ? " " : "" :
                                       null
                                       );
                    }

                    var namedOnly = this.GetExtraVerbatimText(ast);
                    if (namedOnly != null)
                    {
                        res.Append(namedOnly);
                    }

                    format.Append(
                        res,
                        Parameters.Length != 0 ?
                        format.SpaceWithinFunctionDeclarationParens :
                        format.SpaceWithinEmptyParameterList,
                        " ",
                        "",
                        this.GetFourthWhiteSpaceDefaultNull(ast)
                        );

                    if (!this.IsMissingCloseGrouping(ast))
                    {
                        res.Append(')');
                    }

                    if (ReturnAnnotation != null)
                    {
                        format.Append(
                            res,
                            format.SpaceAroundAnnotationArrow,
                            " ",
                            string.Empty,
                            this.GetFifthWhiteSpace(ast)
                            );
                        res.Append("->");
                        ReturnAnnotation.AppendCodeString(
                            res,
                            ast,
                            format,
                            format.SpaceAroundAnnotationArrow != null ?
                            format.SpaceAroundAnnotationArrow.Value ? " " : string.Empty :
                            null
                            );
                    }

                    Body?.AppendCodeString(res, ast, format);
                }
            }
        }