9 _formatter_parent_source_chunks_pendingNewlines _pendingSpace_pendingNested_pendingFlushLeft _afterComment_rules_hardSplitRules _lazyRules _openSpans_nesting_blockArgumentNesting_preventSplitNesting pageWidthrulewrite writeNewline writeSpacesplit writeComments_writeCommentTextindentunindent startSpanendSpan startRule _activateRule startLazyRuleendRule forceRulesnestExpressionunneststartSelectionFromEndendSelectionFromEndstartBlockArgumentNestingendBlockArgumentNesting startBlockendBlockend preventSplitendPreventSplit_emitPendingWhitespace_chunkForComment_isGenericMethodComment_needsSpaceBeforeComment_needsSpaceAfterComment_needsBlankLineBeforeComment _writeSplit _writeText _startChunk _divideChunks _canDivide_handleHardSplit _hardenRules_trailingIdentifierChar_javaDocComment _javaDocLine_leadingIndentation ChunkBuilderrRegExp SourceVisitorChunk DartFormatter SourceCodeListintboolRuleOpenSpanNestingBuilder NestingLevel pageWidthlastindentmergeEmptySplitsvoidStringforEachclear commitNestingisDouble flushLeftnestspacedummyisHard SourceCommentfirst linesBeforeilengtheverycommenttype CommentType inlineBlock updateSplit isNotEmptyselectionStarttext selectionEndcontainsfixesStyleFix docCommentschunk firstMatchsplittoList trimRightminisEmptyremoveAt removeLastaddline substringspacesIndentblockunindentcostCostnormalstartSpanrule isHardenedspansoutersplitsOnInnerRulesconstrainWhenSplit expressionnowunneststartSelectionFromEndendSelectionFromEndcurrentNesting LineWriter BlockChunk argumentChunk indentation_childrenhard startRule forceSplitunsplitBlockLength forceRulestraceChunkBuilderloggreen dumpChunks writeLinesisCompilationUnituriselectionLength WhitespacedocendsWith startsWithhasMatchhardennesting appendText LineSplitter preventDivideindexisNestedconstrainedRulesother constrainfullySplitValueד`Gd{[Dg math dart:math chunk.dart comment_type.dart'constants.dart@dart_formatter.dart^qtdebugt debug.dart|line_writer.dartnesting_builder.dartnesting_level.dartrule/rule.dartsource_code.dartsource_comment.dart%style_fix.dartRzN؀ &?]{ҁ$=>‚Ã#deCD$(yÅ"#tdžȆGciRqrLjȉ$%`f܉݊)FL6~ʌ:;njȍ -.Glm56GǏ͏eՐ֑3RswxƑ/5ϓflr DJ-u•ߕ6,DEl—×:ՙ#m|ݚ)DHIL4|ќ 3OUV267 SYIޡ3IPho Q΢ݣ>ZmyӤk#*:N`g"HdjkSߧEf$*+f0K!p̫֫ClҭA^֭$./߯-56`H^İ8R]p&./Ka -pH 9`ntuյֶNuvط (DNVW7?@W]^[_`ûĻ1^ɼ;Y۾ *cimnܾ@nǿ˿̿@6@V@@@@@@AA>ADAAAAB.BSBhBiBBBBBBBCC"C(C,C-CxC~CDDiDDEE[EEEFF8F>FFGG8GKGLGgGGGGGH&H_HeHHHIIIIFIJIKIIIJ+JcJJJJJK5KmKsKKL%LELFLLLLMMGMMMQMRMMMNNNNlNNNNOOOROmOPPKP]PPQQQ:Q;QQQQQRKRrRRRRRRRSCSISST,TcTiTTTTU<UkUUUVV)V?VbVVVVWWWNWWX0XMX^XhXpXvXwXXYY:YMYQYRYYYYYZ Z Z0ZZZ~ZZZZZ[$[%[>[X[[[[\.\\\\\\\\] ]&]\]]]]]]]]^^$^`^d^e^^__7_V_____``8`e`i`j```aAabaaaab%bTbUbbccc!c"cscdd#dAd_dddde e;eeeeef3fQfofffffffg)g/gzgggh,h0h1hhhiifiiijjNjjjkk7k[k\kkkl l9lkllllm m$m%msmmnnLnMnynznnooooiooooopppp p]ppppq!q"qdqqqqqqrrr7rLrgrrrrrs@ssstKtgthtttuu6u@uHuIuuuvvvRvvvvvvwwwwwcw|wwwxxxx;xAxBxxxxxxxy;ynyoyyz z z+z=zAzBzzz{{N{g{{|||6|T|||||}}/}W}}}}}~~<~=~~~~ Vr12~BH Ar?IQWX&Ifntxz ؀ &?]ut{$D5/// Takes the incremental serialized output of [SourceVisitor]--the source text /// along with any comments and preserved whitespace--and produces a coherent /// tree of [Chunk]s which can then be split into physical lines. /// /// Keeps track of leading indentation, expression nesting, and all of the hairy /// code required to seamlessly integrate existing comments into the pure /// output produced by [SourceVisitor].؀  ,$./zpz   %/// The builder for the code surrounding the block that this writer is for, or /// `null` if this is writing the top-level code./// The number of newlines that should be written before the next /// non-whitespace token. /// /// This will always be 0, 1, or 2.eH/// Whether a non-breaking space should be written before the next text.WYY9/// Whether the next chunk should use expression nesting.jtQ0/// Whether the next chunk should be flush left.X  ;/// Whether the most recently written output was a comment.'ɀ/// The nested stack of rules that are currently in use. /// /// New chunks are implicitly split by the innermost rule when the chunk is /// ended.؉ى҉׉Ӊ߂Y&/// The set of rules known to contain hard splits that will in turn force /// these rules to harden. /// /// This is accumulated lazily while chunks are being built. Then, once they /// are all done, the rules are all hardened. We do this later because some /// rules may not have all of their constraints fully wired up until after /// the hard split appears. For example, a hard split in a positional /// argument list needs to force the named arguments to split too, but we /// don't create that rule until after the positional arguments are done.67051=h/// The list of rules that are waiting until the next whitespace has been /// written before they start.ÌȌa?/// The nested stack of spans that are currently being written.)*( 0:OO/// The current state.ZhioĎ  /// The stack of nesting levels where block arguments may start. /// /// A block argument's contents will nest at the last level in this stack.12#0$8/// The number of calls to [preventSplit()] that have not been ended by a /// call to [endPreventSplit()]. /// /// Splitting is completely disabled inside string interpolation. We do want /// to fix the whitespace inside interpolation, though, so we still format /// them. This tracks whether we're inside an interpolation. We can't use a /// simple bool because interpolation can nest. /// /// When this is non-zero, splits are ignored.!pooC/// The number of characters of code that can fit in a single line.?/// The current innermost rule.'Ӗ/// Writes [string], the text for a single token, to the output. /// /// By default, this also implicitly adds one level of nesting if we aren't /// currently nested at all. We do this here so that if a comment appears /// after any token within a statement or top-level form and that comment /// leads to splitting, we correctly nest. Even pathological cases like: /// /// /// import // comment /// "this_gets_nested.dart"; /// /// If we didn't do this here, we'd have to call [nestExpression] after the /// first token of practically every grammar production. /// /// If [mergeEmptySplits] is `true`, the default, then any pending split /// information will be combined with a previously created split if no text /// has been written since. This generally comes into play when text is /// written after a comment. The comment may leave some pending split /// information while [SourceVisitor] may have also created a split and we /// want to combine those. /// /// It is only `false` when writing the contents of a multiline string. There, /// we may *want* to have a series of empty chunks because those represent /// empty lines in the multiline string. ł/// Writes one or two hard newlines. /// /// Doesn't immediately write them. That way line breaking is correctly /// interleaved with any comments that appear before the next token. /// /// If [isDouble] is `true`, inserts an extra blank line. If [flushLeft] is /// `true`, the next line will start at column 1 and ignore indentation and /// nesting. If [nest] is `true` then the next line will use expression /// nesting.ӚKq=/// Writes a space before the subsequent non-whitespace text.u/// Write a split owned by the current innermost rule. /// /// If [nest] is `false`, ignores any current expression nesting. Otherwise, /// uses the current nesting level. If unsplit, it expands to a space if /// [space] is `true`.˛ޞ9T/// Outputs the series of [comments] and associated whitespace that appear /// before [token] (which is not written by this). /// /// The list contains each comment as it appeared in the source between the /// last token written and the next one that's about to be written. /// /// [linesBeforeToken] is the number of lines between the last comment (or /// previous token if there are no comments) and the next token.#('9 A@  p/// Writes the text of [comment]. /// /// If it's a JavaDoc comment that should be fixed to use `///`, fixes it..-7 ?>ƻ&&/// Creates a new indentation level [spaces] deeper than the current one. /// /// If omitted, [spaces] defaults to [Indent.block].. 43b`//// Discards the most recent indentation level.ƀϼ88f/// Starts a new span with [cost]. /// /// Each call to this needs a later matching call to [endSpan].CHGNRSӼ/// Ends the innermost span.pZF/// Starts a new [Rule]. /// /// If omitted, defaults to a new [Rule]. ΀ @΁B5B5Q/// Starts a new [Rule] that comes into play *after* the next whitespace /// (including comments) is written. /// /// This is used for operators who want to start a rule before the first /// operand but not get forced to split if a comment appears before the /// entire expression. /// /// If [rule] is omitted, defaults to a new [Rule].BD BKBJBBB/// Ends the innermost rule.C/EE^/// Pre-emptively forces all of the current rules to become hard splits. /// /// This is called by [SourceVisitor] when it can determine that a rule will /// will always be split. Turning it (and the surrounding rules) into hard /// splits lets the writer break the output into smaller pieces for the line /// splitter, which helps performance and avoids failing on very large input. /// /// In particular, it's easy for the visitor to know that collections with a /// large number of items must split. Doing that early avoids crashing the /// splitter when it tries to recurse on huge collection literals.E΁G G -/// Begins a new expression nesting level [indent] spaces deeper than the /// current one if it splits. /// /// If [indent] is omitted, defaults to [Indent.expression]. If [now] is /// `true`, commits the nesting change immediately instead of waiting until /// after the next chunk of text is written.G G#G"G* G1G0GHH߁6/// Discards the most recent level of expression nesting. /// /// Expressions that are more nested will get increased indentation when split /// if the previous line has a lower level of nesting. /// /// If [now] is `false`, does not commit the nesting change until after the /// next chunk of text is written.H HHIMJjJj /// Marks the selection starting point as occurring [fromEnd] characters to /// the left of the end of what's currently been written. /// /// It counts backwards from the end because this is called *after* the chunk /// of text containing the selection has been output.J JJJiLL /// Marks the selection ending point as occurring [fromEnd] characters to the /// left of the end of what's currently been written. /// /// It counts backwards from the end because this is called *after* the chunk /// of text containing the selection has been output.L LLMTMMd/// Captures the current nesting level as marking where subsequent block /// arguments should start.NNsNsL/// Releases the last nesting level captured by [startBlockArgumentNesting].N3OaOa/// Starts a new block chunk and returns the [ChunkBuilder] for it. /// /// Nested blocks are handled using their own independent [LineWriter].OtO|O{OOOOOOOOR[TT/// Ends this [ChunkBuilder], which must have been created by [startBlock()]. /// /// Forces the chunk that owns the block to split if it can tell that the /// block contents will always split. It does that by looking for hard splits /// in the block that aren't for top level elements in the block. If /// [forceSplit] is `true`, the block always splits. /// /// Returns the previous writer for the surrounding block.TTTTYT^YYn/// Finishes writing and returns a [SourceCode] containing the final output /// and updated selection, if any.]5]]]t]]^g_>_>/// Writes the current pending [Whitespace] to the output, if any. /// /// This should only be called after source lines have been preserved to turn /// any ambiguous whitespace into a concrete choice._]_c_b_t_z_y_m_`lkakak/// Tries to find an existing chunk to append [comment] to. /// /// If [comment] should be appending to an existing line (in other words, /// should be moved before a split), then this returns that [Chunk]. /// Otherwise, returns `null`.a|aaa aafہTgg/// Returns `true` if [comment] appears to be a magic generic method comment. /// /// Those get spaced a little differently to look more like real syntax: /// /// int f/**/(int x) => 3;gggh3jje/// Returns `true` if a space should be output between the end of the current /// output and the subsequent comment which is about to be written. /// /// This is only called if the comment is trailing text in the unformatted /// source. In most cases, a space will be output to separate the comment /// from what precedes it. This returns false if: /// /// * This comment does begin the line in the output even if it didn't in /// the source. /// * The comment is a block comment immediately following a grouping /// character (`(`, `[`, or `{`). This is to allow `foo(/* comment */)`, /// et. al.jjjj jjm'mm/// Returns `true` if a space should be output after the last comment which /// was just written and the token that will be written.mmmm mmp"p'p'pDpSpRq߅6r?r?S/// Starts a new chunk with the given split information. /// /// Returns the chunk.rSrYrXrmrsrrrrrrrrrrrrar}rrwww`/// Writes [text] to either the current chunk or a new one if the current /// chunk is complete.w www wwxȁxxxxxxxyyy yyy$y*y)yy1zDN{U{U/// Pre-processes the chunks after they are done being written by the visitor /// but before they are run through the line splitter. /// /// Marks ranges of chunks that can be line split independently to keep the /// batches we send to [LineSplitter] small.|y}}u/// Returns true if we can divide the chunks at [index] and line split the /// ones before and after that separately.} }'}&]]B/// Hardens the active rules when a hard split occurs within them./// Replaces all of the previously hardened rules with hard splits, along /// with every rule that those constrain to also split. /// /// This should only be called after all chunks have been written.>I/// Matches if the last character of a string is an identifier character.À))_/// Matches a JavaDoc-style doc comment that starts with "/**" and ends with /// "*/" or "**/".;AaBezO/// Matches the leading "*" in a line in the middle of a JavaDoc-style comment.ʃЃރу_1/// Matches spaces at the beginning of as string.06@7N؀ &?]{ҁ$=>‚Ã#deCD$(yÅ"#tdžȆGciRqrLjȉ$%`f܉݊)FL6~ʌ:;njȍ -.Glm56GǏ͏eՐ֑3RswxƑ/5ϓflr DJ-u•ߕ6,DEl—×:ՙ#m|ݚ)DHIL4|ќ 3OUV267 SYIޡ3IPho Q΢ݣ>ZmyӤk#*:N`g"HdjkSߧEf$*+f0K!p̫֫ClҭA^֭$./߯-56`H^İ8R]p&./Ka -pH 9`ntuյֶNuvط (DNVW7?@W]^[_`ûĻ1^ɼ;Y۾ *cimnܾ@nǿ˿̿@6@V@@@@@@AA>ADAAAAB.BSBhBiBBBBBBBCC"C(C,C-CxC~CDDiDDEE[EEEFF8F>FFGG8GKGLGgGGGGGH&H_HeHHHIIIIFIJIKIIIJ+JcJJJJJK5KmKsKKL%LELFLLLLMMGMMMQMRMMMNNNNlNNNNOOOROmOPPKP]PPQQQ:Q;QQQQQRKRrRRRRRRRSCSISST,TcTiTTTTU<UkUUUVV)V?VbVVVVWWWNWWX0XMX^XhXpXvXwXXYY:YMYQYRYYYYYZ Z Z0ZZZ~ZZZZZ[$[%[>[X[[[[\.\\\\\\\\] ]&]\]]]]]]]]^^$^`^d^e^^__7_V_____``8`e`i`j```aAabaaaab%bTbUbbccc!c"cscdd#dAd_dddde e;eeeeef3fQfofffffffg)g/gzgggh,h0h1hhhiifiiijjNjjjkk7k[k\kkkl l9lkllllm m$m%msmmnnLnMnynznnooooiooooopppp p]ppppq!q"qdqqqqqqrrr7rLrgrrrrrs@ssstKtgthtttuu6u@uHuIuuuvvvRvvvvvvwwwwwcw|wwwxxxx;xAxBxxxxxxxy;ynyoyyz z z+z=zAzBzzz{{N{g{{|||6|T|||||}}/}W}}}}}~~<~=~~~~ Vr12~BH Ar?IQWX&Ifntxz_trailingIdentifierChar_javaDocComment _javaDocLine_leadingIndentation ChunkBuilder