internal override void AppendCodeString(StringBuilder res, JAst ast, CodeFormattingOptions format)
 {
     if (_preceeding != null) {
         _preceeding.AppendCodeString(res, ast, format);
     }
     res.Append(_verbatimImage ?? "<error>");
 }

        internal override void AppendCodeString(StringBuilder res, JAst 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(']');
            }
        }

 public override string GetLeadingWhiteSpace(JAst ast)
 {
     if (this.IsAltForm(ast)) {
         return Items[0].GetLeadingWhiteSpace(ast);
     }
     return base.GetLeadingWhiteSpace(ast);
 }

 public override string GetLeadingWhiteSpace(JAst ast)
 {
     if (_sliceStart != null) {
         return _sliceStart.GetLeadingWhiteSpace(ast);
     }
     return this.GetProceedingWhiteSpace(ast);
 }

 internal override void AppendCodeString(StringBuilder res, JAst 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(')');
     }
 }

        /// <summary>
        /// Returns a new SuiteStatement which is composed of a subset of the statements in this suite statement.
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <returns></returns>
        public SuiteStatement CloneSubset(JAst ast, int start, int end)
        {
            Statement[] statements = new Statement[end - start + 1];
            for (int i = start; i <= end; i++) {
                statements[i - start] = Statements[i];
            }

            var res = new SuiteStatement(statements);

            // propagate white space so we stay mostly the same...
            var itemWhiteSpace = this.GetListWhiteSpace(ast);
            var colonWhiteSpace = this.GetProceedingWhiteSpaceDefaultNull(ast);
            if (colonWhiteSpace != null) {
                ast.SetAttribute(res, NodeAttributes.PreceedingWhiteSpace, "");
            } else if (itemWhiteSpace != null) {
                // semi-colon list of statements, must end in a new line, but the original new line
                // could be multiple lines.
                ast.SetAttribute(res, NodeAttributes.ListWhiteSpace, new string[0]);
                var trailingNewLine = this.GetTrailingNewLine(ast);
                if (trailingNewLine != null) {
                    ast.SetAttribute(res, NodeAttributes.TrailingNewLine, "\r\n");
                }
            }

            if (this.IsAltForm(ast)) {
                ast.SetAttribute(res, NodeAttributes.IsAltFormValue, NodeAttributes.IsAltFormValue);
            }

            return res;
        }

 internal override void AppendCodeStringStmt(StringBuilder res, JAst ast, CodeFormattingOptions format)
 {
     foreach(var preceeding in _preceeding) {
         preceeding.AppendCodeString(res, ast, format);
     }
     res.Append(this.GetVerbatimImage(ast) ?? "<error stmt>");
 }

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

 internal override void AppendCodeStringStmt(StringBuilder res, JAst 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, JAst 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(JAst ast)
 {
     var whitespace = this.GetListWhiteSpace(ast);
     if (whitespace != null && whitespace.Length > 0) {
         return whitespace[0];
     }
     return null;
 }

        public override string GetLeadingWhiteSpace(JAst ast)
        {
            if (_left.Length > 0 && _left[0] != null) {
                return _left[0].GetLeadingWhiteSpace(ast);
            }

            return null;
        }

 internal override void AppendCodeString(StringBuilder res, JAst 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, JAst ast, CodeFormattingOptions format)
 {
     var whitespace = this.GetListWhiteSpace(ast);
     for (int i = 0; i < _dotCount; i++) {
         if (whitespace != null) {
             res.Append(whitespace[i]);
         }
         res.Append('.');
     }
     base.AppendCodeString(res, ast, format);
 }

 internal override void AppendCodeStringStmt(StringBuilder res, JAst ast, CodeFormattingOptions format)
 {
     format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
     res.Append("assert");
     _test.AppendCodeString(res, ast, format);
     if (_message != null) {
         res.Append(this.GetSecondWhiteSpace(ast));
         res.Append(',');
         _message.AppendCodeString(res, ast, format);
     }
 }

 internal override void AppendCodeString(StringBuilder res, JAst ast, CodeFormattingOptions format)
 {
     res.Append(this.GetProceedingWhiteSpace(ast));
     res.Append("for");
     _lhs.AppendCodeString(res, ast, format);
     if (!this.IsIncompleteNode(ast)) {
         res.Append(this.GetSecondWhiteSpace(ast));
         res.Append("in");
         _list.AppendCodeString(res, ast, format);
     }
 }

        public override Statement GetBody(JAst root)
        {
            Statement body = _node as Statement;
            if (body == null) {
                var retStmt = new ReturnStatement((Expression)_node);
                retStmt.RoundTripRemoveValueWhiteSpace(root);
                body = retStmt;
            }

            return new SuiteStatement(new[] { body });
        }

 public ExtractedMethodCreator(JAst ast, ScopeStatement[] scopes, HashSet<JVariable> inputVariables, HashSet<JVariable> outputVariables, SelectionTarget target, int indentSize, bool insertTabs)
 {
     _ast = ast;
     _scopes = scopes;
     _inputVars = new List<JVariable>(inputVariables);
     _outputVars = new List<JVariable>(outputVariables);
     _inputVars.Sort(CompareVariables);
     _outputVars.Sort(CompareVariables);
     _target = target;
     _indentSize = indentSize;
     _insertTabs = insertTabs;
 }

 internal override void AppendCodeString(StringBuilder res, JAst ast, CodeFormattingOptions format)
 {
     format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
     res.Append("yield");
     if (!this.IsAltForm(ast)) {
         _expression.AppendCodeString(res, ast, format);
         var itemWhiteSpace = this.GetListWhiteSpace(ast);
         if (itemWhiteSpace != null) {
             res.Append(",");
             res.Append(itemWhiteSpace[0]);
         }
     }
 }

        internal override void AppendCodeStringStmt(StringBuilder res, JAst ast, CodeFormattingOptions format)
        {
            var namesWhiteSpace = this.GetNamesWhiteSpace(ast);

            if (namesWhiteSpace != null) {
                ListExpression.AppendItems(res, ast, format, "global", "", this, Names.Count, (i, sb) => {
                    sb.Append(namesWhiteSpace[i]);
                    Names[i].AppendCodeString(res, ast, format);
                });
            } else {
                ListExpression.AppendItems(res, ast, format, "global", "", this, Names.Count, (i, sb) => Names[i].AppendCodeString(sb, ast, format));
            }
        }