internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
            Target.AppendCodeString(res, ast, format);
            format.Append(
                res,
                format.SpaceBeforeIndexBracket,
                " ",
                "",
                this.GetProceedingWhiteSpace(ast)
            );

            res.Append('[');
            _index.AppendCodeString(
                res, 
                ast, 
                format, 
                format.SpaceWithinIndexBrackets != null ? format.SpaceWithinIndexBrackets.Value ? " " : "" : null
            );

            if (!this.IsMissingCloseGrouping(ast)) {
                format.Append(
                    res,
                    format.SpaceWithinIndexBrackets,
                    " ",
                    "",
                    this.GetSecondWhiteSpace(ast)
                );
                res.Append(']');
            }
        }

 internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format, string leadingWhiteSpace) {
     string kwOnlyText = this.GetExtraVerbatimText(ast);
     if (kwOnlyText != null) {
         if (leadingWhiteSpace != null) {
             res.Append(leadingWhiteSpace);
             res.Append(kwOnlyText.TrimStart());
             leadingWhiteSpace = null;
         } else {
             res.Append(kwOnlyText);
         }
     }
     bool isAltForm = this.IsAltForm(ast);
     if (isAltForm) {
         res.Append(leadingWhiteSpace ?? this.GetProceedingWhiteSpace(ast));
         res.Append('(');
         leadingWhiteSpace = null;
     }
     _error.AppendCodeString(res, ast, format, leadingWhiteSpace);
     if (this.DefaultValue != null) {
         res.Append(this.GetSecondWhiteSpace(ast));
         res.Append('=');
         this.DefaultValue.AppendCodeString(res, ast, format);
     }
     if (isAltForm && !this.IsMissingCloseGrouping(ast)) {
         res.Append(this.GetSecondWhiteSpace(ast));
         res.Append(')');
     }
 }

        internal static IEnumerable<IScopeNode> EnumerateBody(PythonAst ast, Statement body, bool includeAssignments = true) {
            SuiteStatement suite = body as SuiteStatement;
            if (suite != null) {
                foreach (Statement stmt in suite.Statements) {
                    ClassDefinition klass = stmt as ClassDefinition;
                    if (klass != null) {
                        yield return new ClassScopeNode(klass);
                        continue;
                    }

                    FunctionDefinition func = stmt as FunctionDefinition;
                    if (func != null) {
                        yield return new FunctionScopeNode(func);
                        continue;
                    }

                    AssignmentStatement assign;
                    if (includeAssignments && (assign = stmt as AssignmentStatement) != null) {
                        foreach (var target in assign.Left) {
                            NameExpression name = target as NameExpression;
                            if (name != null) {
                                yield return new AssignmentScopeNode(ast, assign, name);
                            }
                        }
                    }
                }
            }
        }

 public override bool Walk(PythonAst node) {
     if (_ast != node) {
         throw new InvalidOperationException("walking wrong AST");
     }
     _scope.Push(_members);
     return base.Walk(node);
 }

 internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
     if (this.IsAltForm(ast)) {
         this.AppendCodeString(res, ast, format, "", "", _item);
     } else {
         this.AppendCodeString(res, ast, format, "(", this.IsMissingCloseGrouping(ast) ? "" : ")", _item);
     }
 }

 public override string GetLeadingWhiteSpace(PythonAst ast) {
     var whitespace = this.GetListWhiteSpace(ast);
     if (whitespace != null && whitespace.Length > 0) {
         return whitespace[0];
     }
     return null;
 }

 public override string GetLeadingWhiteSpace(PythonAst ast) {
     var decorateWhiteSpace = this.GetNamesWhiteSpace(ast);
     if (decorateWhiteSpace != null && decorateWhiteSpace.Length > 0) {
         return decorateWhiteSpace[0];
     }
     return "";
 }

 public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace) {
     if (this.IsAltForm(ast)) {
         Items[0].SetLeadingWhiteSpace(ast, whiteSpace);
     } else {
         base.SetLeadingWhiteSpace(ast, whiteSpace);
     }
 }

 public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace) {
     var decorateWhiteSpace = this.GetNamesWhiteSpace(ast);
     if (decorateWhiteSpace != null && decorateWhiteSpace.Length > 0) {
         decorateWhiteSpace[0] = whiteSpace;
     }
     
 }

        public void UpdateTree(PythonAst newAst, IAnalysisCookie newCookie) {
            lock (this) {
                if (_updatesPending > 0) {
                    _updatesPending--;
                }
                if (newAst == null) {
                    // there was an error in parsing, just let the waiter go...
                    if (_curWaiter != null) {
                        _curWaiter.Set();
                    }
                    _tree = null;
                    return;
                }

                _tree = newAst;
                _cookie = newCookie;

                if (_curWaiter != null) {
                    _curWaiter.Set();
                }
            }

            var newParse = OnNewParseTree;
            if (newParse != null) {
                newParse(this, EventArgs.Empty);
            }
        }

 internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
     _left.AppendCodeString(res, ast, format);
     res.Append(this.GetProceedingWhiteSpace(ast));
     res.Append(_op.ToCodeString());
     res.Append('=');
     _right.AppendCodeString(res, ast, format);
 }

        internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
            Expression left = _left;
            Expression right = _right;
            string op1, op2;

            if (Operator == PythonOperator.NotIn) {
                op1 = "not";
                if (!this.IsIncompleteNode(ast)) {
                    op2 = "in";
                } else {
                    op2 = null;
                }
            } else if (Operator == PythonOperator.IsNot) {
                op1 = "is";
                op2 = "not";
            } else if ((op1 = this.GetVerbatimImage(ast)) != null) {
                // operator image differs from the operator enum, for example <> is always NotEqual which is !=
                // so we store the verbatim image and use it here.
                op2 = null;
            } else {
                op1 = Operator.ToCodeString();
                op2 = null;
            }
            BinaryToCodeString(res, ast, format, this, _left, _right, op1, op2);
        }

        internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
            format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
            res.Append("with");
            var itemWhiteSpace = this.GetListWhiteSpace(ast);
            int whiteSpaceIndex = 0;
            for (int i = 0; i < _items.Length; i++) {
                var item = _items[i];
                if (i != 0) {
                    if (itemWhiteSpace != null) {
                        res.Append(itemWhiteSpace[whiteSpaceIndex++]);
                    }
                    res.Append(',');
                }

                item.ContextManager.AppendCodeString(res, ast, format);
                if (item.Variable != null) {
                    if (itemWhiteSpace != null) {
                        res.Append(itemWhiteSpace[whiteSpaceIndex++]);
                    } else {
                        res.Append(' ');
                    }
                    res.Append("as");
                    item.Variable.AppendCodeString(res, ast, format);
                }
            }

            _body.AppendCodeString(res, ast, format);
        }

 internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
     format.ReflowComment(res, this.GetProceedingWhiteSpaceDefaultNull(ast));
     if (format.UseVerbatimImage) {
         res.Append(this.GetVerbatimImage(ast) ?? _name);
     } else {
         res.Append(_name);
     }
 }

 public AstPythonParameterInfo(PythonAst ast, Parameter p) {
     Name = p.Name;
     Documentation = "";
     DefaultValue = p.DefaultValue?.ToCodeString(ast) ?? "";
     IsParamArray = p.Kind == ParameterKind.List;
     IsKeywordDict = p.Kind == ParameterKind.Dictionary;
     ParameterTypes = new IPythonType[0];
 }

 public CoverageMapper(PythonAst ast, string filename, HashSet<int> hits) {
     _ast = ast;
     _filename = filename;
     GlobalScope = new CoverageScope(ast);
     CurScopes.Add(GlobalScope);
     _blockCount++;
     _hits = hits;
 }

        public AstPythonType(PythonAst ast, IPythonModule declModule, ClassDefinition def, string doc, LocationInfo loc) {
            _members = new Dictionary<string, IMember>();

            Name = def.Name;
            Documentation = doc;
            DeclaringModule = declModule;
            Mro = new IPythonType[0];
            Locations = new[] { loc };
        }

 internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
     format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
     res.Append('`');
     _expression.AppendCodeString(res, ast, format);
     if (!this.IsMissingCloseGrouping(ast)) {
         res.Append(this.GetSecondWhiteSpace(ast));
         res.Append('`');
     }
 }

 internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
     _target.AppendCodeString(res, ast, format);
     res.Append(this.GetProceedingWhiteSpaceDefaultNull(ast));
     res.Append('.');
     if (!this.IsIncompleteNode(ast)) {
         res.Append(this.GetSecondWhiteSpaceDefaultNull(ast));
         res.Append(this.GetVerbatimImage(ast) ?? _name);
     }
 }

        public OverviewWalker(ProjectEntry entry, AnalysisUnit topAnalysis, PythonAst tree) {
            _entry = entry;
            _curUnit = topAnalysis;

            _tree = tree;
            Debug.Assert(_tree != null);

            _scope = topAnalysis.Scope;
        }