fourmolu 0.19.0.1 → 0.21.0.0

raw patch · 377 files changed

Files

• CHANGELOG.md +217/−30
• LICENSE.md +1/−1
• README.md +75/−64
• app/Main.hs +3/−4
• data/examples/declaration/data/comment-in-empty-record-four-out.hs +6/−0
• data/examples/declaration/data/comment-in-empty-record-out.hs +6/−0
• data/examples/declaration/data/comment-in-empty-record.hs +5/−0
• data/examples/declaration/data/haddock-before-deriving-four-out.hs +5/−0
• data/examples/declaration/data/haddock-before-deriving-out.hs +5/−0
• data/examples/declaration/data/haddock-before-deriving.hs +3/−0
• data/examples/declaration/data/haddock-before-record-braces-four-out.hs +6/−0
• data/examples/declaration/data/haddock-before-record-braces-out.hs +6/−0
• data/examples/declaration/data/haddock-before-record-braces.hs +5/−0
• data/examples/declaration/data/infix-haddocks-out.hs +2/−2
• data/examples/declaration/data/linear-four-out.hs +11/−0
• data/examples/declaration/data/linear-out.hs +11/−0
• data/examples/declaration/data/linear.hs +10/−0
• data/examples/declaration/data/record-empty-haddock-four-out.hs +5/−0
• data/examples/declaration/data/record-empty-haddock-out.hs +5/−0
• data/examples/declaration/data/record-empty-haddock.hs +6/−0
• data/examples/declaration/data/record-four-out.hs +1/−1
• data/examples/declaration/data/record-out.hs +1/−1
• data/examples/declaration/data/record.hs +1/−1
• data/examples/declaration/data/required-type-arguments-four-out.hs +25/−0
• data/examples/declaration/data/required-type-arguments-out.hs +27/−0
• data/examples/declaration/data/required-type-arguments.hs +24/−0
• data/examples/declaration/data/unnamed-field-comment-3-out.hs +1/−5
• data/examples/declaration/data/unpack-field-comment-0-four-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-0-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-0.hs +2/−0
• data/examples/declaration/data/unpack-field-comment-1-four-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-1-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-1.hs +2/−0
• data/examples/declaration/data/unpack-field-comment-2-four-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-2-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-2.hs +3/−0
• data/examples/declaration/data/unpack-field-comment-3-four-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-3-out.hs +4/−0
• data/examples/declaration/data/unpack-field-comment-3.hs +3/−0
• data/examples/declaration/foreign/foreign-import-multiline-four-out.hs +8/−0
• data/examples/declaration/foreign/foreign-import-multiline-out.hs +8/−0
• data/examples/declaration/foreign/foreign-import-multiline.hs +6/−0
• data/examples/declaration/rewrite-rule/prelude2-four-out.hs +1/−1
• data/examples/declaration/rewrite-rule/prelude2-out.hs +1/−1
• data/examples/declaration/rewrite-rule/prelude2.hs +1/−1
• data/examples/declaration/rewrite-rule/prelude4-four-out.hs +1/−0
• data/examples/declaration/rewrite-rule/prelude4-out.hs +1/−0
• data/examples/declaration/signature/specialize/specialize-2-four-out.hs +8/−0
• data/examples/declaration/signature/specialize/specialize-2-out.hs +8/−0
• data/examples/declaration/signature/specialize/specialize-2.hs +9/−0
• data/examples/declaration/signature/specialize/specialize-3-four-out.hs +10/−0
• data/examples/declaration/signature/specialize/specialize-3-out.hs +10/−0
• data/examples/declaration/signature/specialize/specialize-3.hs +4/−0
• data/examples/declaration/type-families/closed-type-family/multi-line-four-out.hs +1/−2
• data/examples/declaration/type-families/closed-type-family/multi-line-out.hs +1/−2
• data/examples/declaration/type-synonyms/multi-line-four-out.hs +1/−2
• data/examples/declaration/type-synonyms/multi-line-out.hs +1/−2
• data/examples/declaration/value/function/arrow/proc-do-complex-four-out.hs +2/−3
• data/examples/declaration/value/function/arrow/proc-do-complex-out.hs +2/−3
• data/examples/declaration/value/function/arrow/proc-do-complex.hs +1/−1
• data/examples/declaration/value/function/arrow/proc-lambdas-four-out.hs +1/−2
• data/examples/declaration/value/function/arrow/proc-lambdas-out.hs +1/−2
• data/examples/declaration/value/function/awkward-comment-0-four-out.hs +1/−2
• data/examples/declaration/value/function/awkward-comment-0-out.hs +1/−2
• data/examples/declaration/value/function/awkward-comment-1-four-out.hs +1/−2
• data/examples/declaration/value/function/awkward-comment-1-out.hs +1/−2
• data/examples/declaration/value/function/case-comment-after-pattern-four-out.hs +3/−0
• data/examples/declaration/value/function/case-comment-after-pattern-out.hs +3/−0
• data/examples/declaration/value/function/case-comment-after-pattern.hs +3/−0
• data/examples/declaration/value/function/case-comment-between-alt-and-where-four-out.hs +6/−0
• data/examples/declaration/value/function/case-comment-between-alt-and-where-out.hs +6/−0
• data/examples/declaration/value/function/case-comment-between-alt-and-where.hs +6/−0
• data/examples/declaration/value/function/case-multi-line-four-out.hs +1/−2
• data/examples/declaration/value/function/case-multi-line-out.hs +1/−2
• data/examples/declaration/value/function/case-single-line-with-braces-four-out.hs +2/−0
• data/examples/declaration/value/function/case-single-line-with-braces-out.hs +2/−0
• data/examples/declaration/value/function/case-single-line-with-braces.hs +2/−0
• data/examples/declaration/value/function/case-with-comment-before-where-four-out.hs +14/−0
• data/examples/declaration/value/function/case-with-comment-before-where-out.hs +14/−0
• data/examples/declaration/value/function/case-with-comment-before-where.hs +14/−0
• data/examples/declaration/value/function/do-multiline-with-case-four-out.hs +13/−0
• data/examples/declaration/value/function/do-multiline-with-case-out.hs +13/−0
• data/examples/declaration/value/function/do-multiline-with-case.hs +13/−0
• data/examples/declaration/value/function/do-single-line-case-guards-four-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-case-guards-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-case-guards.hs +2/−0
• data/examples/declaration/value/function/do-single-line-lambda-case-four-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-lambda-case-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-lambda-case.hs +2/−0
• data/examples/declaration/value/function/do-single-line-multiple-cases-four-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-multiple-cases-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-multiple-cases.hs +2/−0
• data/examples/declaration/value/function/do-single-line-nested-case-four-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-nested-case-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-nested-case.hs +2/−0
• data/examples/declaration/value/function/do-single-line-with-case-four-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-with-case-out.hs +2/−0
• data/examples/declaration/value/function/do-single-line-with-case.hs +2/−0
• data/examples/declaration/value/function/guards-four-out.hs +2/−0
• data/examples/declaration/value/function/guards-out.hs +2/−0
• data/examples/declaration/value/function/guards.hs +2/−0
• data/examples/declaration/value/function/infix/dollar-chains-1-four-out.hs +3/−3
• data/examples/declaration/value/function/infix/dollar-chains-1-out.hs +3/−3
• data/examples/declaration/value/function/infix/dollar-chains-3-four-out.hs +8/−8
• data/examples/declaration/value/function/infix/dollar-chains-3-out.hs +8/−8
• data/examples/declaration/value/function/infix/dollar-chains-4-four-out.hs +4/−4
• data/examples/declaration/value/function/infix/dollar-chains-4-out.hs +4/−4
• data/examples/declaration/value/function/infix/lenses-four-out.hs +8/−8
• data/examples/declaration/value/function/infix/lenses-out.hs +8/−8
• data/examples/declaration/value/function/infix/op-chain-r-eq-dollar-1-four-out.hs +8/−8
• data/examples/declaration/value/function/infix/op-chain-r-eq-dollar-1-out.hs +8/−8
• data/examples/declaration/value/function/infix/op-chain-r-eq-dollar-2-four-out.hs +8/−8
• data/examples/declaration/value/function/infix/op-chain-r-eq-dollar-2-out.hs +8/−8
• data/examples/declaration/value/function/infix/op-chain-r-s-dollar-four-out.hs +4/−4
• data/examples/declaration/value/function/infix/op-chain-r-s-dollar-out.hs +4/−4
• data/examples/declaration/value/function/infix/qualified-ops-four-out.hs +8/−8
• data/examples/declaration/value/function/infix/qualified-ops-out.hs +8/−8
• data/examples/declaration/value/function/lambda-comment-after-arrow-four-out.hs +2/−0
• data/examples/declaration/value/function/lambda-comment-after-arrow-out.hs +2/−0
• data/examples/declaration/value/function/lambda-comment-after-arrow.hs +2/−0
• data/examples/declaration/value/function/linear-bindings-four-out.hs +9/−0
• data/examples/declaration/value/function/linear-bindings-out.hs +9/−0
• data/examples/declaration/value/function/linear-bindings.hs +9/−0
• data/examples/declaration/value/function/multiline-strings-9-four-out.hs +11/−0
• data/examples/declaration/value/function/multiline-strings-9-out.hs +11/−0
• data/examples/declaration/value/function/multiline-strings-9.hs +11/−0
• data/examples/declaration/value/function/newline-single-line-body-four-out.hs +1/−2
• data/examples/declaration/value/function/newline-single-line-body-out.hs +1/−2
• data/examples/declaration/value/function/operator-comments-3-four-out.hs +5/−0
• data/examples/declaration/value/function/operator-comments-3-out.hs +5/−0
• data/examples/declaration/value/function/operator-comments-3.hs +5/−0
• data/examples/declaration/value/function/operator-comments-4-four-out.hs +4/−0
• data/examples/declaration/value/function/operator-comments-4-out.hs +4/−0
• data/examples/declaration/value/function/operator-comments-4.hs +4/−0
• data/examples/declaration/value/function/pattern/or-patterns-four-out.hs +9/−1
• data/examples/declaration/value/function/pattern/or-patterns-out.hs +9/−1
• data/examples/declaration/value/function/pattern/or-patterns.hs +7/−1
• data/examples/declaration/value/function/record/wildcard-comments-0-four-out.hs +12/−0
• data/examples/declaration/value/function/record/wildcard-comments-0-out.hs +12/−0
• data/examples/declaration/value/function/record/wildcard-comments-0.hs +11/−0
• data/examples/declaration/value/function/record/wildcard-comments-1-four-out.hs +12/−0
• data/examples/declaration/value/function/record/wildcard-comments-1-out.hs +12/−0
• data/examples/declaration/value/function/record/wildcard-comments-1.hs +11/−0
• data/examples/declaration/value/function/strings-four-out.hs +2/−0
• data/examples/declaration/value/function/strings-out.hs +2/−0
• data/examples/declaration/value/function/strings.hs +2/−0
• data/examples/declaration/value/pattern-synonyms/explicitely-bidirectional-four-out.hs +8/−8
• data/examples/fixity/megaparsec-alternative-four-out.hs +8/−0
• data/examples/fixity/megaparsec-alternative-out.hs +8/−0
• data/examples/fixity/megaparsec-alternative.hs +8/−0
• data/examples/fixity/optics-mixed-four-out.hs +8/−0
• data/examples/fixity/optics-mixed-out.hs +8/−0
• data/examples/fixity/optics-mixed.hs +8/−0
• data/examples/fixity/relude-default-operator-chain-four-out.hs +10/−0
• data/examples/fixity/relude-default-operator-chain-out.hs +10/−0
• data/examples/fixity/relude-default-operator-chain.hs +10/−0
• data/examples/fixity/relude-default-operator-four-out.hs +7/−0
• data/examples/fixity/relude-default-operator-out.hs +7/−0
• data/examples/fixity/relude-default-operator.hs +7/−0
• data/examples/fixity/rio-ampersand-four-out.hs +7/−0
• data/examples/fixity/rio-ampersand-out.hs +7/−0
• data/examples/fixity/rio-ampersand.hs +7/−0
• data/examples/fixity/rio-deepseq-four-out.hs +7/−0
• data/examples/fixity/rio-deepseq-out.hs +7/−0
• data/examples/fixity/rio-deepseq.hs +7/−0
• data/examples/import/comment-before-merged-import-lists-four-out.hs +7/−0
• data/examples/import/comment-before-merged-import-lists-out.hs +7/−0
• data/examples/import/comment-before-merged-import-lists.hs +7/−0
• data/examples/import/comment-before-merged-imports-four-out.hs +7/−0
• data/examples/import/comment-before-merged-imports-out.hs +7/−0
• data/examples/import/comment-before-merged-imports.hs +3/−0
• data/examples/import/comment-between-merged-imports-four-out.hs +6/−0
• data/examples/import/comment-between-merged-imports-out.hs +7/−0
• data/examples/import/comment-between-merged-imports.hs +6/−0
• data/examples/import/comment-inside-empty-import-list-four-out.hs +6/−0
• data/examples/import/comment-inside-empty-import-list-out.hs +6/−0
• data/examples/import/comment-inside-empty-import-list.hs +5/−0
• data/examples/import/comment-inside-sorted-import-list-four-out.hs +7/−0
• data/examples/import/comment-inside-sorted-import-list-out.hs +7/−0
• data/examples/import/comment-inside-sorted-import-list.hs +7/−0
• data/examples/import/comments-inside-imports-out.hs +2/−3
• data/examples/import/comments-per-import-four-out.hs +1/−2
• data/examples/import/comments-per-import-out.hs +1/−2
• data/examples/import/data-four-out.hs +7/−0
• data/examples/import/data-out.hs +7/−0
• data/examples/import/data.hs +6/−0
• data/examples/import/explicit-imports-with-comments-four-out.hs +2/−4
• data/examples/import/explicit-imports-with-comments-out.hs +3/−5
• data/examples/import/explicit-level-imports-four-out.hs +16/−0
• data/examples/import/explicit-level-imports-out.hs +16/−0
• data/examples/import/explicit-level-imports-qualified-post-four-out.hs +5/−0
• data/examples/import/explicit-level-imports-qualified-post-out.hs +5/−0
• data/examples/import/explicit-level-imports-qualified-post.hs +5/−0
• data/examples/import/explicit-level-imports.hs +14/−0
• data/examples/import/implicit-prelude-package-four-out.hs +7/−0
• data/examples/import/implicit-prelude-package-out.hs +7/−0
• data/examples/import/implicit-prelude-package.hs +7/−0
• data/examples/import/merging-0-four-out.hs +4/−1
• data/examples/import/merging-0-out.hs +4/−1
• data/examples/import/merging-1-four-out.hs +4/−1
• data/examples/import/merging-1-out.hs +4/−1
• data/examples/import/merging-2-four-out.hs +8/−2
• data/examples/import/merging-2-out.hs +8/−2
• data/examples/import/no-implicit-prelude-four-out.hs +6/−0
• data/examples/import/no-implicit-prelude-out.hs +6/−0
• data/examples/import/no-implicit-prelude-package-four-out.hs +8/−0
• data/examples/import/no-implicit-prelude-package-out.hs +8/−0
• data/examples/import/no-implicit-prelude-package.hs +8/−0
• data/examples/import/no-implicit-prelude.hs +6/−0
• data/examples/import/simple-four-out.hs +10/−2
• data/examples/import/simple-out.hs +10/−2
• data/examples/module-header/block-haddock-in-export-list-four-out.hs +4/−0
• data/examples/module-header/block-haddock-in-export-list-out.hs +5/−0
• data/examples/module-header/block-haddock-in-export-list.hs +1/−0
• data/examples/module-header/empty-haddock-four-out.hs +2/−0
• data/examples/module-header/empty-haddock-out.hs +2/−0
• data/examples/other/block-comment-before-argument-four-out.hs +5/−0
• data/examples/other/block-comment-before-argument-out.hs +5/−0
• data/examples/other/block-comment-before-argument.hs +4/−0
• data/examples/other/block-comment-before-element-four-out.hs +6/−0
• data/examples/other/block-comment-before-element-out.hs +6/−0
• data/examples/other/block-comment-before-element.hs +6/−0
• data/examples/other/comment-around-quasiquote-four-out.hs +9/−0
• data/examples/other/comment-around-quasiquote-out.hs +9/−0
• data/examples/other/comment-around-quasiquote.hs +9/−0
• data/examples/other/comment-block-section-heading-four-out.hs +3/−0
• data/examples/other/comment-block-section-heading-out.hs +3/−0
• data/examples/other/comment-block-section-heading.hs +3/−0
• data/examples/other/comment-glued-together-out.hs +1/−1
• data/examples/other/comment-in-empty-list-four-out.hs +9/−0
• data/examples/other/comment-in-empty-list-out.hs +9/−0
• data/examples/other/comment-in-empty-list.hs +6/−0
• data/examples/other/comment-opening-a-list-four-out.hs +11/−0
• data/examples/other/comment-opening-a-list-out.hs +11/−0
• data/examples/other/comment-opening-a-list.hs +11/−0
• data/examples/other/comment-style-transform-out.hs +17/−14
• data/examples/other/comment-trailing-blank-line-do-four-out.hs +4/−0
• data/examples/other/comment-trailing-blank-line-do-out.hs +4/−0
• data/examples/other/comment-trailing-blank-line-do.hs +4/−0
• data/examples/other/comment-trailing-blank-line-let-four-out.hs +5/−0
• data/examples/other/comment-trailing-blank-line-let-out.hs +5/−0
• data/examples/other/comment-trailing-blank-line-let.hs +5/−0
• data/examples/other/comment-trailing-blank-line-variants-four-out.hs +22/−0
• data/examples/other/comment-trailing-blank-line-variants-out.hs +22/−0
• data/examples/other/comment-trailing-blank-line-variants.hs +22/−0
• data/examples/other/comment-trailing-blank-line-where-four-out.hs +5/−0
• data/examples/other/comment-trailing-blank-line-where-out.hs +5/−0
• data/examples/other/comment-trailing-blank-line-where.hs +5/−0
• data/examples/other/comment-trailing-no-blank-line-four-out.hs +25/−0
• data/examples/other/comment-trailing-no-blank-line-out.hs +25/−0
• data/examples/other/comment-trailing-no-blank-line.hs +25/−0
• data/examples/other/comment-trigger-escaping-four-out.hs +15/−0
• data/examples/other/comment-trigger-escaping-out.hs +15/−0
• data/examples/other/comment-trigger-escaping.hs +15/−0
• data/examples/other/comment-two-blocks-four-out.hs +3/−2
• data/examples/other/comment-two-blocks-out.hs +3/−2
• data/examples/other/empty-forall-four-out.hs +1/−1
• data/examples/other/empty-forall-out.hs +1/−1
• data/examples/other/empty-haddock-four-out.hs +5/−1
• data/examples/other/empty-haddock-out.hs +6/−2
• data/examples/other/invalid-haddock-weird-four-out.hs +1/−3
• data/examples/other/invalid-haddock-weird-out.hs +1/−3
• data/examples/other/pragma-below-header-four-out.hs +19/−0
• data/examples/other/pragma-below-header-out.hs +19/−0
• data/examples/other/pragma-below-header.hs +18/−0
• data/examples/other/pragma-comment-multi-extension-four-out.hs +5/−0
• data/examples/other/pragma-comment-multi-extension-out.hs +5/−0
• data/examples/other/pragma-comment-multi-extension.hs +4/−0
• data/fourmolu/haddock-style/output-auto-module=auto.hs +38/−0
• data/fourmolu/haddock-style/output-auto-module=multi_line.hs +39/−0
• data/fourmolu/haddock-style/output-auto-module=multi_line_compact.hs +39/−0
• data/fourmolu/haddock-style/output-auto-module=single_line.hs +38/−0
• data/fourmolu/haddock-style/output-auto.hs +38/−0
• data/fourmolu/haddock-style/output-multi_line-module=auto.hs +41/−0
• data/fourmolu/haddock-style/output-multi_line-module=multi_line.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line-module=multi_line_compact.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line-module=single_line.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line_compact-module=auto.hs +41/−0
• data/fourmolu/haddock-style/output-multi_line_compact-module=multi_line.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line_compact-module=multi_line_compact.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line_compact-module=single_line.hs +1/−1
• data/fourmolu/haddock-style/output-multi_line_compact.hs +1/−1
• data/fourmolu/haddock-style/output-single_line-module=auto.hs +36/−0
• data/fourmolu/import-grouping/input.hs +7/−0
• data/fourmolu/import-grouping/output-by_qualified.hs +6/−0
• data/fourmolu/import-grouping/output-by_scope.hs +6/−0
• data/fourmolu/import-grouping/output-by_scope_then_qualified.hs +6/−0
• data/fourmolu/import-grouping/output-custom.hs +7/−0
• data/fourmolu/import-grouping/output-preserve.hs +7/−0
• data/fourmolu/import-grouping/output-single.hs +6/−0
• data/fourmolu/indentation/input.hs +6/−0
• data/fourmolu/indentation/output-2-indent_wheres.hs +6/−0
• data/fourmolu/indentation/output-2.hs +6/−0
• data/fourmolu/indentation/output-3-indent_wheres.hs +6/−0
• data/fourmolu/indentation/output-3.hs +6/−0
• data/fourmolu/indentation/output-4-indent_wheres.hs +6/−0
• data/fourmolu/indentation/output-4.hs +6/−0
• data/fourmolu/record-style/input.hs +24/−0
• data/fourmolu/record-style/output-aligned-leading.hs +35/−0
• data/fourmolu/record-style/output-aligned-trailing.hs +35/−0
• data/fourmolu/record-style/output-knr-leading.hs +35/−0
• data/fourmolu/record-style/output-knr-trailing.hs +35/−0
• data/fourmolu/sort-deriving-clauses/input.hs +1/−1
• data/fourmolu/sort-deriving-clauses/output-False.hs +1/−1
• data/fourmolu/sort-deriving-clauses/output-True.hs +1/−2
• data/fourmolu/trailing-section-operators/output-True.hs +5/−5
• data/fourmolu/unicode-syntax/output-always.hs +2/−2
• data/fourmolu/unicode-syntax/output-detect.hs +2/−2
• data/fourmolu/unicode-syntax/output-never.hs +2/−2
• extract-hackage-info/hackage-info.bin binary
• fixity-tests/test-1-no-extra-info-expected.hs +11/−11
• fixity-tests/test-1-with-fixity-info-expected.hs +8/−8
• fourmolu.cabal +28/−16
• fourmolu.yaml +2/−1
• src/GHC/DynFlags.hs +6/−0
• src/Ormolu.hs +56/−20
• src/Ormolu/Comments/Anchor.hs +326/−0
• src/Ormolu/Comments/Invariants.hs +135/−0
• src/Ormolu/Comments/Tree.hs +74/−0
• src/Ormolu/Config.hs +7/−4
• src/Ormolu/Config/Gen.hs +48/−4
• src/Ormolu/Config/Types.hs +47/−40
• src/Ormolu/Diff/ParseResult.hs +77/−7
• src/Ormolu/Diff/Text.hs +1/−5
• src/Ormolu/Exception.hs +25/−4
• src/Ormolu/Fixity.hs +1/−1
• src/Ormolu/Fixity/Imports.hs +1/−1
• src/Ormolu/Fixity/Internal.hs +7/−61
• src/Ormolu/Imports.hs +89/−31
• src/Ormolu/Imports/Grouping.hs +84/−20
• src/Ormolu/Parser.hs +51/−19
• src/Ormolu/Parser/CommentStream.hs +251/−105
• src/Ormolu/Parser/Pragma.hs +1/−1
• src/Ormolu/Parser/Result.hs +24/−3
• src/Ormolu/Printer.hs +85/−22
• src/Ormolu/Printer/Combinators.hs +172/−62
• src/Ormolu/Printer/CommentPlacement.hs +57/−0
• src/Ormolu/Printer/Comments.hs +110/−188
• src/Ormolu/Printer/Internal.hs +196/−151
• src/Ormolu/Printer/Meat/Common.hs +247/−54
• src/Ormolu/Printer/Meat/Declaration.hs +22/−14
• src/Ormolu/Printer/Meat/Declaration/Class.hs +8/−3
• src/Ormolu/Printer/Meat/Declaration/Data.hs +185/−98
• src/Ormolu/Printer/Meat/Declaration/Foreign.hs +13/−8
• src/Ormolu/Printer/Meat/Declaration/Instance.hs +1/−1
• src/Ormolu/Printer/Meat/Declaration/OpTree.hs +57/−28
• src/Ormolu/Printer/Meat/Declaration/RoleAnnotation.hs +1/−1
• src/Ormolu/Printer/Meat/Declaration/Rule.hs +16/−14
• src/Ormolu/Printer/Meat/Declaration/Signature.hs +67/−13
• src/Ormolu/Printer/Meat/Declaration/Signature.hs-boot +14/−0
• src/Ormolu/Printer/Meat/Declaration/StringLiteral.hs +31/−18
• src/Ormolu/Printer/Meat/Declaration/Type.hs +10/−3
• src/Ormolu/Printer/Meat/Declaration/TypeFamily.hs +11/−6
• src/Ormolu/Printer/Meat/Declaration/Value.hs +212/−168
• src/Ormolu/Printer/Meat/ImportExport.hs +37/−10
• src/Ormolu/Printer/Meat/Module.hs +47/−22
• src/Ormolu/Printer/Meat/Pragma.hs +10/−3
• src/Ormolu/Printer/Meat/Type.hs +195/−367
• src/Ormolu/Printer/Meat/Type/Function.hs +493/−0
• src/Ormolu/Printer/Operators.hs +32/−32
• src/Ormolu/Printer/SpanStream.hs +0/−49
• src/Ormolu/Processing/Common.hs +2/−2
• src/Ormolu/Processing/Preprocess.hs +15/−8
• src/Ormolu/Terminal.hs +2/−2
• src/Ormolu/Utils.hs +24/−14
• src/Ormolu/Utils/Fixity.hs +5/−5
• src/Ormolu/Utils/Glob.hs +4/−0
• src/Ormolu/Utils/IO.hs +30/−19
• tests/Ormolu/Comments/AnchorSpec.hs +140/−0
• tests/Ormolu/Config/PrinterOptsSpec.hs +80/−61
• tests/Ormolu/ConfigSpec.hs +92/−199
• tests/Ormolu/Fixity/ParserSpec.hs +1/−1
• tests/Ormolu/FixitySpec.hs +8/−20
• tests/Ormolu/Integration/Utils.hs +3/−2
• tests/Ormolu/PrinterSpec.hs +12/−40
• tests/Ormolu/TestConfig.hs +49/−0

@@ -1,6 +1,193 @@+## Fourmolu 0.21.0.0++* Import lines separated by comments without blank lines are now considered one import group++### Upstream changes:++#### Ormolu 0.9.0.0++* Comments are now attached to the syntax tree by position, before anything+  is printed, rather than by a cursor advanced as the printer walks the+  tree. Which element owns a comment no longer depends on the order in which+  the printer happens to visit things, so comments stop escaping the+  construct they were written in when Ormolu sorts or regroups it: a comment+  inside an import list stays there, a comment after a quasi-quote stops+  floating to the bottom of the file, and a comment attached to an import+  travels with that import when the imports are sorted. [Issue+  1074](https://github.com/tweag/ormolu/issues/1074) and [issue+  1076](https://github.com/tweag/ormolu/issues/1076).++* Haddock comments are now printed as they were written instead of being+  rebuilt from the documentation string GHC parsed out of them. A `{- | …+  -}` stays a block comment rather than becoming `--` lines, an empty `-- |`+  is no longer dropped, and a `{- *** … -}` section heading keeps its+  meaning. [Issue 641](https://github.com/tweag/ormolu/issues/641), [issue+  822](https://github.com/tweag/ormolu/issues/822), and [issue+  1159](https://github.com/tweag/ormolu/issues/1159).++  Ormolu still puts a space after a Haddock's trigger, re-indents a block+  Haddock to line up with the code it documents, and rewrites a trailing `--+  ^ X` as a leading `-- | X` when it moves the comment in front of what it+  documents.++* Backslashes are no longer added to lines in the middle of a comment block,+  where Haddock does not look for a trigger anyway. [Issue+  1131](https://github.com/tweag/ormolu/issues/1131).++* A comment written on its own line in front of an operator no longer+  strands the operator at the start of the next line. In a `do` block that+  changed what the code meant, because `$` at the beginning of a line is+  read as a new statement rather than as a continuation of the previous one.+  [Issue 1028](https://github.com/tweag/ormolu/issues/1028).++* A comment written after `=`, `->`, or a lambda arrow now stays on that+  line instead of being pushed onto the next one, and the result is+  idempotent. `f x = -- note` no longer becomes an `=` stranded on a line of+  its own. [Issue 786](https://github.com/tweag/ormolu/issues/786), [issue+  810](https://github.com/tweag/ormolu/issues/810), and [issue+  936](https://github.com/tweag/ormolu/issues/936).++* Layout decisions now take comments into account. A comment that falls+  inside a construct can no longer be squeezed into a single-line rendering+  of it.++* A comment block that trails a line of code and continues below it no+  longer drops to the start of the line, which could put the rest of the+  block outside the construct it was written in.++* A construct that brackets its contents is no longer put on one line when+  something inside it is documented with a `-- |` Haddock. Such a Haddock+  takes whole lines, so it used to swallow the closing bracket: a documented+  `deriving` clause came out as `deriving (-- | B`, and a documented field+  of a short record as `{-- | …`, which did not even parse. [Issue+  752](https://github.com/tweag/ormolu/issues/752) and [issue+  1164](https://github.com/tweag/ormolu/issues/1164).++  A `{- | … -}` Haddock is self-delimiting and does not force anything, so+  a declaration documented that way is left as it was written rather than+  being broken up: `data A = A {- | a number -} Int Bool` stays on one line+  where it used to be spread over five.++* Only pragmas in the file header are hoisted to the top of the module now.+  A `LANGUAGE` or `OPTIONS_GHC` pragma written after the first import or+  declaration stays where it is, and no longer drags the comments above it+  to the top of the file. GHC reads the header and stops, so such a pragma+  never affected compilation; moving it was giving it an effect it did not+  have. [Issue 1168](https://github.com/tweag/ormolu/issues/1168).++* A comment above a `{-# LANGUAGE A, B #-}` pragma is no longer duplicated+  when the pragma is split into one per extension; it stays with the first.+  [Issue 787](https://github.com/tweag/ormolu/issues/787).++* Ormolu now checks that the comments of the output correspond to the+  comments of the input—none dropped, duplicated, invented, or reordered—and+  refuses to format when they do not. This runs alongside the existing check+  that the AST is unchanged, is disabled by `--unsafe`, and costs nothing+  extra: the printer already records where it put each comment.++## Fourmolu 0.20.1.0++### Upstream changes:++#### Ormolu 0.8.2.0++* Overhaul how operator fixity information is collected. In addition to the+  Hoogle database, Ormolu now parses the sources of a curated set of important+  packages directly, which yields more accurate and complete fixity data than+  before. In particular it recovers fixities for operators re-exported through+  umbrella modules (e.g. `Servant.API`, `Control.Lens`) that recent Hoogle+  databases no longer record. As a result, formatting of operator chains is+  improved out of the box, and users should expect some operator-heavy code to+  be laid out differently (and more correctly) than in previous releases.++* Improve the layout of chains of `infixr 0` operators (`$`, `seq`, `?:`, and+  the like). Such operators are only laid out in the trailing "staircase" style+  when it is warranted: either the chain consists of a single operator, or its+  final operand is a hanging construct (a `do` block, lambda, `case`, etc.). A+  chain of several such operators that ends in an ordinary expression is now+  laid out with the operators in the leading position instead of an+  ever-deepening pyramid. [Issue+  1151](https://github.com/tweag/ormolu/issues/1151).++* Do not crash when a parent directory cannot be read due to insufficient+  permissions while searching for configuration files; the search for+  configuration files is stopped at that point instead. [Issue+  1212](https://github.com/tweag/ormolu/issues/1212).++* Preserve blank lines between blocks in layout contexts (`where`, `do`,+  `let`) when the preceding block ends with a trailing comment. [Issue+  1132](https://github.com/tweag/ormolu/issues/1132).++* Fix printing of single line export lists with inlined Haddock comments.+  [Issue 1051](https://github.com/tweag/ormolu/issues/1051).++* Fix preservation of the position of comments around the `where` keyword.+  [Issue 784](https://github.com/tweag/ormolu/issues/784).++* Do not sort `Prelude` to the end of the import list when the+  `NoImplicitPrelude` extension is enabled; instead sort it like any other+  import. [Issue 1189](https://github.com/tweag/ormolu/issues/1189).++## Fourmolu 0.20.0.0++Now installable with GHCup! See README for details.++* Improve `import-grouping` configuration++    * Add the `scope` option for import grouping ([#525](https://github.com/fourmolu/fourmolu/pull/525)).++    * Deprecate the `match` option for import grouping in favor of `glob` and `scope` ([#525](https://github.com/fourmolu/fourmolu/pull/525)).++    * Add the `import-list` option for import grouping ([#522](https://github.com/fourmolu/fourmolu/pull/522)).++* Add a `record-style` to configure the placement of record braces. ([#467](https://github.com/fourmolu/fourmolu/issues/467))++* Fix applying `indent-wheres` configuration to pattern synonyms with explicit bidirectional `where` clauses ([#486](https://github.com/fourmolu/fourmolu/issues/486))++### Upstream changes:++#### Ormolu 0.8.1.1++* Add missing braces for case expressions in single‑line do blocks. [Issue 1180](https://github.com/tweag/ormolu/issues/1180).++* Fix the import grouping logic in the presence of imports with explicit levels. [Issue 1192](https://github.com/tweag/ormolu/issues/1192).++#### Ormolu 0.8.1.0++* Fix printing of guards on pattern binds. [Issue+  1178](https://github.com/tweag/ormolu/issues/1178).++* Switched to `ghc-lib-parser-9.14`, with the following new syntactic features:+   * GHC proposal [#493](https://github.com/ghc-proposals/ghc-proposals/blob/e2c683698323cec3e33625369ae2b5f585387c70/proposals/0493-specialise-expressions.rst): expressions in SPECIALISE pragmas+   * Multiline strings in foreign import declarations.+   * `ExplicitNamespaces` supports the `data` namespace specifier in import and export lists, replacing `pattern`.+   * `LinearTypes` adds new syntax to support non-linear record fields.+   * `RequiredTypeArguments` allows visible forall in GADT syntax.++* Updated to `Cabal-syntax-3.16`.++* Correctly format string literals containing the `\^\` escape sequence. [Issue+  1165](https://github.com/tweag/ormolu/issues/1165).++* Correctly preserve consecutive blank lines in multiline strings. [Issue+  1194](https://github.com/tweag/ormolu/issues/1194).++* Fix printing of multi-line or-patterns inside as-patterns. [Issue+  1183](https://github.com/tweag/ormolu/issues/1183).++* Fix an issue where or-patterns would be indented twice. [Issue+  1188](https://github.com/tweag/ormolu/issues/1188).++* Add support for `ExplicitLevelImports`. [Issue+  1192](https://github.com/tweag/ormolu/issues/1192).+ ## Fourmolu 0.19.0.1 -* Fixed a performance regression introduced in 0.8.0.0. [Issue+### Upstream changes:++#### Ormolu 0.8.0.2++* Fix a performance regression introduced in 0.8.0.0. [Issue   1176](https://github.com/tweag/ormolu/issues/1176).  ## Fourmolu 0.19.0.0@@ -429,7 +616,7 @@  #### Ormolu 0.5.0.1 -* Fixed a bug in the diff printing functionality. [Issue+* Fix a bug in the diff printing functionality. [Issue   886](https://github.com/tweag/ormolu/issues/886).  * Indent closing bracket for list comprehensions in `do` blocks.@@ -722,7 +909,7 @@ * Now `--mode check` fails on missing trailing blank lines. [Issue   743](https://github.com/tweag/ormolu/issues/743). -* Fixed indentation of arrow forms in do blocks. [Issue+* Fix indentation of arrow forms in do blocks. [Issue   739](https://github.com/tweag/ormolu/issues/739).  #### Ormolu 0.1.4.1@@ -735,7 +922,7 @@ * Added support for monad comprehensions. [Issue   665](https://github.com/tweag/ormolu/issues/665). -* Fixed a bug when a space was inserted in front of promoted types even when+* Fix a bug when a space was inserted in front of promoted types even when   it wasn't strictly necessary. [Issue   668](https://github.com/tweag/ormolu/issues/668). @@ -745,7 +932,7 @@  #### Ormolu 0.1.3.1 -* Fixed a problem with multiline record updates using the record dot+* Fix a problem with multiline record updates using the record dot   preprocessor. [Issue 658](https://github.com/tweag/ormolu/issues/658).  ## Fourmolu 0.3.0.0@@ -780,7 +967,7 @@  #### Ormolu 0.1.2.0: -* Fixed the bug when comments in different styles got glued together after+* Fix the bug when comments in different styles got glued together after   formatting. [Issue 589](https://github.com/tweag/ormolu/issues/589).  * Added `-i` as a shortcut for `--mode inplace`. [Issue@@ -809,26 +996,26 @@ * Improved sorting of operators in imports. [Issue   602](https://github.com/tweag/ormolu/issues/602). -* Fixed a bug related to trailing space in multiline comments in certain+* Fix a bug related to trailing space in multiline comments in certain   cases. [Issue 603](https://github.com/tweag/ormolu/issues/602).  * Added support for formatting linked lists with `(:)` as line terminator.   [Issue 478](https://github.com/tweag/ormolu/issues/478). -* Fixed rendering of function arguments in multiline layout. [Issue+* Fix rendering of function arguments in multiline layout. [Issue   609](https://github.com/tweag/ormolu/issues/609).  * Blank lines between definitions in `let` and `while` bindings are now   preserved. [Issue 554](https://github.com/tweag/ormolu/issues/554). -* Fixed the bug when type applications stuck to the `$` of TH splices that+* Fix the bug when type applications stuck to the `$` of TH splices that   followed them. [Issue 613](https://github.com/tweag/ormolu/issues/613).  * Improved region formatting so that indented fragments—such as definitions   inside of `where` clauses—can be formatted. [Issue   572](https://github.com/tweag/ormolu/issues/572). -* Fixed the bug related to the de-association of pragma comments. [Issue+* Fix the bug related to the de-association of pragma comments. [Issue   619](https://github.com/tweag/ormolu/issues/619).  ## Fourmolu 0.1.0.0@@ -841,24 +1028,24 @@  #### Ormolu 0.1.0.0: -* Fixed rendering of type signatures concerning several identifiers. [Issue+* Fix rendering of type signatures concerning several identifiers. [Issue   566](https://github.com/tweag/ormolu/issues/566). -* Fixed an idempotence issue with inline comments in tuples and parentheses.+* Fix an idempotence issue with inline comments in tuples and parentheses.   [Issue 450](https://github.com/tweag/ormolu/issues/450). -* Fixed an idempotence issue when certain comments were picked up as+* Fix an idempotence issue when certain comments were picked up as   “continuation” of a series of comments [Issue   449](https://github.com/tweag/ormolu/issues/449). -* Fixed an idempotence issue related to different indentation levels in a+* Fix an idempotence issue related to different indentation levels in a   comment series. [Issue 512](https://github.com/tweag/ormolu/issues/512). -* Fixed an idempotence issue related to comments which may happen to be+* Fix an idempotence issue related to comments which may happen to be   separated from the elements they are attached to by the equality sign.   [Issue 340](https://github.com/tweag/ormolu/issues/340). -* Fixed an idempotence issue with type synonym and data declarations where+* Fix an idempotence issue with type synonym and data declarations where   the type has a Haddock. [Issue   578](https://github.com/tweag/ormolu/issues/578). @@ -866,17 +1053,17 @@   multiple blank lines in a row. [Issue   518](https://github.com/tweag/ormolu/issues/518). -* Fixed rendering of comments around if expressions. [Issue+* Fix rendering of comments around if expressions. [Issue   458](https://github.com/tweag/ormolu/issues/458).  * Unnamed fields of data constructors are now documented using the `-- ^`   syntax. [Issue 445](https://github.com/tweag/ormolu/issues/445) and [Issue   428](https://github.com/tweag/ormolu/issues/428). -* Fixed non-idempotent transformation of partly documented data definition.+* Fix non-idempotent transformation of partly documented data definition.   [Issue 590](https://github.com/tweag/ormolu/issues/590). -* Fixed an idempotence issue related to operators. [Issue+* Fix an idempotence issue related to operators. [Issue   522](https://github.com/tweag/ormolu/issues/522).  * Renamed the `--check-idempotency` flag to `--check-idempotence`.@@ -907,7 +1094,7 @@   select a region to format. [Issue   516](https://github.com/tweag/ormolu/issues/516). -* Fixed rendering of module headers in the presence of preceding comments or+* Fix rendering of module headers in the presence of preceding comments or   Haddocks. [Issue 561](https://github.com/tweag/ormolu/issues/561).  ## Ormolu 0.0.4.0@@ -928,7 +1115,7 @@   now put on its own line. [Issue   509](https://github.com/tweag/ormolu/issues/509). -* Fixed the bug pertaining to rendering of arrow notation with multiline+* Fix the bug pertaining to rendering of arrow notation with multiline   expressions. [Issue 513](https://github.com/tweag/ormolu/issues/513).  * Made rendering of data type definitions, value-level applications, and@@ -946,15 +1133,15 @@  ## Ormolu 0.0.3.1 -* Fixed rendering of record updates with the record dot preprocessor syntax+* Fix rendering of record updates with the record dot preprocessor syntax   [Issue 498](https://github.com/tweag/ormolu/issues/498).  ## Ormolu 0.0.3.0 -* Fixed an issue related to unnecessary use of curly braces. [Issue+* Fix an issue related to unnecessary use of curly braces. [Issue   473](https://github.com/tweag/ormolu/issues/473). -* Fixed the issue with formatting multi-way if when it happens to be a+* Fix the issue with formatting multi-way if when it happens to be a   function applied to arguments [Issue   488](https://github.com/tweag/ormolu/issues/488). This changed the way   multi-line if is formatted in general.@@ -966,7 +1153,7 @@   potentially-hanging consturctions in the presence of comments. [Issue   447](https://github.com/tweag/ormolu/issues/447). -* Fixed indentation in presence of type applications. [Issue+* Fix indentation in presence of type applications. [Issue   493](https://github.com/tweag/ormolu/issues/493).  * Class and instance declarations now do not have a blank line after@@ -984,20 +1171,20 @@ * Now unrecognized GHC options passed with `--ghc-opt` cause Ormolu to fail   (exit code 7). -* Fixed formatting of result type in closed type families. See [issue+* Fix formatting of result type in closed type families. See [issue   420](https://github.com/tweag/ormolu/issues/420). -* Fixed a minor inconsistency between formatting of normal and foreign type+* Fix a minor inconsistency between formatting of normal and foreign type   signatures. See [issue 408](https://github.com/tweag/ormolu/issues/408). -* Fixed a bug when comment before module header with Haddock was moved+* Fix a bug when comment before module header with Haddock was moved   inside the export list. See [issue   430](https://github.com/tweag/ormolu/issues/430).  * Empty `forall`s are now correctly preserved. See [issue   429](https://github.com/tweag/ormolu/issues/429). -* Fixed [issue 446](https://github.com/tweag/ormolu/issues/446), which+* Fix [issue 446](https://github.com/tweag/ormolu/issues/446), which   involved braces and operators.  * When there are comments between preceding Haddock (pipe-style) and its@@ -1017,7 +1204,7 @@ * Sorting language pragmas cannot not change meaning of the input program   anymore. [Issue 404](https://github.com/tweag/ormolu/issues/404). -* Fixed formatting of applications where function is a complex expression.+* Fix formatting of applications where function is a complex expression.   [Issue 444](https://github.com/tweag/ormolu/issues/444).  ## Ormolu 0.0.1.0

@@ -12,7 +12,7 @@   notice, this list of conditions and the following disclaimer in the   documentation and/or other materials provided with the distribution. -* Neither the name Tweag I/O nor the names of contributors may be used to+* Neither the names Tweag I/O and Mark Karpov nor the names of contributors may be used to   endorse or promote products derived from this software without specific   prior written permission. 

@@ -26,20 +26,18 @@  We share all bar one of Ormolu's goals: -* Using GHC's own parser to avoid parsing problems caused by+* Use GHC's own parser to avoid the parsing problems caused by   [`haskell-src-exts`](https://hackage.haskell.org/package/haskell-src-exts).-* Let some whitespace be programmable. The layout of the input influences-  the layout choices in the output. This means that the choices between-  single-line/multi-line layouts in certain situations are made by the user,-  not by an algorithm. This makes the implementation simpler and leaves some-  control to the user while still guaranteeing that the formatted code is-  stylistically consistent.-* Writing code in such a way so it's easy to modify and maintain.-* That formatting style aims to result in minimal diffs.+* Make some whitespace programmable. The layout of the input influences the+  layout choices in the output, so the choice between single-line and+  multi-line layouts is made by the user rather than by an algorithm. This+  keeps the implementation simpler and leaves some control to the user while+  still guaranteeing that the formatted code is stylistically consistent.+* Produce minimal diffs. * Choose a style compatible with modern dialects of Haskell. As new Haskell-  extensions enter broad use, we may change the style to accommodate them.-* Idempotence: formatting already formatted code doesn't change it.-* Be well-tested and robust so that the formatter can be used in large+  extensions enter broad use, we may adjust the style to accommodate them.+* Guarantee idempotence: formatting already formatted code doesn't change it.+* Stay well-tested and robust, so that the formatter can be used in large   projects. * ~~Implementing one “true” formatting style which admits no configuration.~~ We allow configuration of various parameters, via CLI options or config files. We encourage any contributions which add further flexibility. @@ -49,13 +47,24 @@  ## Installation -To install the latest release from Hackage, simply install with Cabal or Stack:+### (Recommended) Install with GHCup -```console-$ cabal install fourmolu-$ stack install fourmolu+```bash+ghcup config add-release-channel 3rdparty+ghcup install fourmolu latest ``` +### Install with Cabal/Stack++```bash+cabal install fourmolu+stack install fourmolu+```++### Install with [dotslash](https://dotslash-cli.com/docs/)++Copy the configuration in the GitHub release notes.+ ## Building from source  ```console@@ -67,13 +76,13 @@  ## Usage -The following will print the formatted output to the standard output.+The following prints the formatted output to the standard output:  ```console $ fourmolu Module.hs ``` -Add `-i` (or `--mode inplace`) to replace the contents of the input file with the formatted output.+Add `-i` (or `--mode inplace`) to replace the contents of the input file with the formatted output:  ```console $ fourmolu -i Module.hs@@ -93,7 +102,7 @@ $ git ls-files -z '*.hs' | xargs -P 12 -0 fourmolu --mode inplace ``` -To check if files are already formatted (useful on CI):+To check whether files are already formatted (useful on CI):  ```console $ fourmolu --mode check src@@ -115,19 +124,20 @@  Fourmolu can be integrated with your editor via the [Haskell Language Server](https://haskell-language-server.readthedocs.io/en/latest/index.html). Just set `haskell.formattingProvider` to `fourmolu` ([instructions](https://haskell-language-server.readthedocs.io/en/latest/configuration.html#language-specific-server-options)). -### GitHub actions+### GitHub Actions -[`run-fourmolu`](https://github.com/haskell-actions/run-fourmolu) is the recommended way to ensure that a project is formatted with Fourmolu.+[`run-fourmolu`](https://github.com/haskell-actions/run-fourmolu) is the recommended way to ensure that a project stays formatted with Fourmolu.  ### Language extensions, dependencies, and fixities  Fourmolu automatically locates the Cabal file that corresponds to a given-source code file. Cabal files are used to extract both default extensions-and dependencies. Default extensions directly affect behavior of the GHC-parser, while dependencies are used to figure out fixities of operators that-appear in the source code. Fixities can also be overridden via the `fixities` configuration option in `fourmolu.yaml`. When the input comes from-stdin, one can pass `--stdin-input-file` which will give Fourmolu the location-that should be used as the starting point for searching for `.cabal` files.+source file. Cabal files are used to extract both default extensions and+dependencies. Default extensions directly affect the behavior of the GHC+parser, while dependencies are used to determine the fixities of operators+that appear in the source code. Fixities can also be overridden via the `fixities` configuration option in+`fourmolu.yaml`. When the input comes from stdin, you+can pass `--stdin-input-file` to tell Fourmolu which location to use as the+starting point when searching for `.cabal` files.  Here is an example of the `fixities` configuration: @@ -145,21 +155,20 @@   - infixr 3.7 <~> ``` -It uses exactly the same syntax as usual Haskell fixity declarations to make-it easier for Haskellers to edit and maintain. Since Ormolu 0.7.8.0-fractional precedences are supported for more precise control over-formatting of complex operator chains.+It uses exactly the same syntax as ordinary Haskell fixity declarations,+which makes it easier for Haskellers to edit and maintain. Since Ormolu+0.7.8.0, fractional precedences are supported for more precise control over+the formatting of complex operator chains.  `fourmolu.yaml` can also contain instructions about-module re-exports that Fourmolu should be aware of. This might be desirable-because at the moment Fourmolu cannot know about all possible module-re-exports in the ecosystem and only few of them are actually important when-it comes to fixity deduction. In 99% of cases the user won't have to do-anything, especially since most common re-exports are already programmed-into Fourmolu. (You are welcome to open PRs to make Fourmolu aware of more-re-exports by default.) However, when the fixity of an operator is not-inferred correctly, making Fourmolu aware of a re-export may come in handy.-Here is an example:+module re-exports that Fourmolu should be aware of. This can be useful because+Fourmolu cannot know about every possible module re-export in the ecosystem,+and only a few of them actually matter for fixity deduction. In 99% of cases+you won't have to do anything, especially since the most common re-exports+are already built into Fourmolu. (You are welcome to open PRs upstream to Ormolu to make Fourmolu+aware of more re-exports by default.) However, when the fixity of an operator+is not inferred correctly, making Fourmolu aware of a re-export may help. Here+is an example:  ```yaml reexports:@@ -194,22 +203,22 @@ {- FOURMOLU_ENABLE -} ``` -This allows us to disable formatting selectively for code between these-markers or disable it for the entire file. To achieve the latter, just put-`{- FOURMOLU_DISABLE -}` at the very top. Note that for Fourmolu to work the-fragments where Fourmolu is enabled must be parseable on their own. Because of-that the magic comments cannot be placed arbitrarily, but rather must-enclose independent top-level definitions.+These let you disable formatting selectively for the code between the two+markers, or for the entire file. To disable formatting for the whole file,+just put `{- FOURMOLU_DISABLE -}` at the very top. Note that the fragments+where Fourmolu is enabled must be parseable on their own. Because of this, the+magic comments cannot be placed arbitrarily; they must enclose independent+top-level definitions.  `{- ORMOLU_DISABLE -}` and `{- ORMOLU_ENABLE -}`, respectively, can be used to the same effect, and the two styles of magic comments can be mixed.  ### Regions -One can ask Fourmolu to format a region of input and leave the rest-unformatted. This is accomplished by passing the `--start-line` and-`--end-line` command line options. `--start-line` defaults to the beginning-of the file, while `--end-line` defaults to the end.+You can ask Fourmolu to format a region of the input and leave the rest+unformatted by passing the `--start-line` and `--end-line` command line+options. `--start-line` defaults to the beginning of the file, and+`--end-line` defaults to the end.  Note that the selected region needs to be parseable Haskell code on its own. @@ -228,6 +237,7 @@ 8         | Cabal file parsing failed 9         | Missing input file path when using stdin input and accounting for .cabal files 10        | Parse error while parsing fixity overrides+11        | Comments of original and formatted code differ 100       | In checking mode: unformatted files 101       | Inplace mode does not work with stdin 102       | Other issue (with multiple input files)@@ -235,10 +245,10 @@  ### Using as a library -The `fourmolu` package can also be depended upon from other Haskell programs.-For these purposes only the top `Ormolu` module should be considered stable.-It follows [PVP](https://pvp.haskell.org/) starting from the version-0.10.2.0. Rely on other modules at your own risk.+The `fourmolu` package can also be used as a dependency from other Haskell+programs. For this purpose, only the top-level `Ormolu` module should be+considered stable. It follows the [PVP](https://pvp.haskell.org/) starting+from version 0.5.3.0. Rely on other modules at your own risk.  ## Troubleshooting @@ -253,25 +263,26 @@   specify the correct fixities in a `fourmolu.yaml` file.  * If this is a third-party operator (e.g. from `base` or some other package-  from Hackage), Ormolu probably doesn't recognize that the operator is the+  on Hackage), Ormolu probably doesn't recognize that the operator is the   same as the third-party one. -  Some reasons this might be the case:+  Some possible reasons for this: -    * You might have a custom Prelude that re-exports things from Prelude-    * You might have `-XNoImplicitPrelude` turned on+    * You have a custom Prelude that re-exports things from the standard+      Prelude.+    * You have `-XNoImplicitPrelude` turned on. -  If any of these are true, make sure to specify the reexports correctly in-  a `fourmolu.yaml` file.+  If either of these applies, make sure to specify the re-exports correctly+  in a `fourmolu.yaml` file. -You can see how Ormolu decides the fixity of operators if you use `--debug`.+You can see how Ormolu decides the fixity of operators by using `--debug`.  ## Limitations  * CPP support is experimental. CPP is virtually impossible to handle-  correctly, so we process them as a sort of unchangeable snippets. This-  works only in simple cases when CPP conditionals surround top-level-  declarations. See the [CPP](https://github.com/tweag/ormolu/blob/master/DESIGN.md#cpp) section in the design notes for a+  correctly, so Fourmolu treats CPP sections as unchangeable snippets. This+  works only in simple cases, where CPP conditionals surround top-level+  declarations. See the [CPP][design-cpp] section of the design notes for a   discussion of the dangers. * Various minor idempotence issues, most of them are related to comments or column limits. 

@@ -220,7 +220,7 @@           InPlace -> do             hPutStrLn               stderr-              "In place editing is not supported when input comes from stdin."+              "In-place editing is not supported when the input comes from stdin."             -- 101 is different from all the other exit codes we already use.             return (ExitFailure 101)           Check -> do@@ -284,7 +284,7 @@         Nothing -> return ExitSuccess         Just diff -> do           runTerm (printTextDiff diff) (cfgColorMode rawConfig) stderr-          -- 100 is different to all the other exit code that are emitted+          -- 100 is different from all the other exit codes that are emitted           -- either from an 'OrmoluException' or from 'error' and           -- 'notImplemented'.           return (ExitFailure 100)@@ -468,7 +468,7 @@         help "Fail if formatting is not idempotent"       ]     -- We cannot parse the source type here, because we might need to do-    -- autodection based on the input file extension (not available here)+    -- autodetection based on the input file extension (not available here)     -- before storing the resolved value in the config struct.     <*> pure ModuleSource     <*> (option parseColorMode . mconcat)@@ -492,7 +492,6 @@     <*> pure defaultPrinterOpts -- unused; overwritten in resolveConfig     <*> (fmap Set.fromList . many . strOption . mconcat)       [ long "local-modules",-        short 'm',         metavar "LOCAL_MODULES",         help "Modules Fourmolu should consider as local by the current Cabal package"       ]

@@ -0,0 +1,6 @@+instance StateKey ExampleReq where+    data State ExampleReq = ExampleState+        {+        -- in here you can put any state that the+        -- run.+        }

@@ -0,0 +1,6 @@+instance StateKey ExampleReq where+  data State ExampleReq = ExampleState+    {+    -- in here you can put any state that the+    -- run.+    }

@@ -0,0 +1,5 @@+instance StateKey ExampleReq where+  data State ExampleReq = ExampleState {+        -- in here you can put any state that the+        -- run.+        }

@@ -0,0 +1,5 @@+data A = A+    deriving+        ( -- | B+          Eq+        )

@@ -0,0 +1,5 @@+data A = A+  deriving+    ( -- | B+      Eq+    )

@@ -0,0 +1,3 @@+data A = A+  -- | B+  deriving (Eq)

@@ -0,0 +1,6 @@+module Example where++data Hello = Hello+    { hello :: String+    -- ^ hello world+    }

@@ -0,0 +1,6 @@+module Example where++data Hello = Hello+  { -- | hello world+    hello :: String+  }

@@ -0,0 +1,5 @@+module Example where++data Hello = Hello+  -- | hello world+  {hello :: String}

@@ -24,8 +24,8 @@  data DocPartial   = Left -- ^ left docs-    -- on multiple-    -- lines+         -- on multiple+         -- lines       :*:       Right   | -- | op

@@ -0,0 +1,11 @@+{-# LANGUAGE LinearTypes #-}++data Record = Rec {x %'Many :: Int, y :: Char}++data T2 a b c where+    MkT2 :: a -> b %1 -> c %1 -> T2 a b c++data T2 a b c = MkT2 {x %Many :: a, y :: b, z :: c}++data T3 a m where+    MkT3 :: a %m -> T3 a m

@@ -0,0 +1,11 @@+{-# LANGUAGE LinearTypes #-}++data Record = Rec {x %'Many :: Int, y :: Char}++data T2 a b c where+  MkT2 :: a -> b %1 -> c %1 -> T2 a b c++data T2 a b c = MkT2 {x %Many :: a, y :: b, z :: c}++data T3 a m where+  MkT3 :: a %m -> T3 a m

@@ -0,0 +1,10 @@+{-# LANGUAGE LinearTypes #-}+data Record = Rec { x %'Many :: Int, y :: Char }++data T2 a b c where+    MkT2 :: a -> b %1 -> c %1 -> T2 a b c++data T2 a b c = MkT2 { x %Many :: a, y :: b, z :: c }++data T3 a m where+    MkT3 :: a %m -> T3 a m

@@ -0,0 +1,5 @@+data A = A+    { -- \|+      --+      a :: Int+    }

@@ -0,0 +1,5 @@+data A = A+  { -- \|+    --+    a :: Int+  }

@@ -0,0 +1,6 @@+data A = A+  {+    -- |+    -- +    a :: Int+  }

@@ -11,7 +11,7 @@     , fooGag       , fooGog ::         NonEmpty-            ( Indentity+            ( Identity                 Bool             )     -- ^ GagGog

@@ -12,7 +12,7 @@     fooGag,     fooGog ::       NonEmpty-        ( Indentity+        ( Identity             Bool         ),     -- | Huh!

@@ -6,7 +6,7 @@   { fooX :: Int -- ^ X   , fooY :: Int -- ^ Y   , fooBar, fooBaz :: NonEmpty (Identity Bool) -- ^ BarBaz-  , fooGag, fooGog :: NonEmpty (Indentity+  , fooGag, fooGog :: NonEmpty (Identity                                   Bool)     -- ^ GagGog   , fooFoo

@@ -0,0 +1,25 @@+data T a where+    Typed :: forall a -> a -> T a++f1 (Typed a x) = x :: a+f2 (Typed Int n) = n * 2+f3 (Typed ((->) w Bool) g) = not . g++data D x where+    MkD1 ::+        forall a b ->+        a ->+        b ->+        D (a, b)+    MkD2 ::+        forall a.+        forall b ->+        a ->+        b ->+        D (a, b)+    MkD3 ::+        forall a ->+        a ->+        forall b ->+        b ->+        D (a, b)

@@ -0,0 +1,27 @@+data T a where+  Typed :: forall a -> a -> T a++f1 (Typed a x) = x :: a++f2 (Typed Int n) = n * 2++f3 (Typed ((->) w Bool) g) = not . g++data D x where+  MkD1 ::+    forall a b ->+    a ->+    b ->+    D (a, b)+  MkD2 ::+    forall a.+    forall b ->+    a ->+    b ->+    D (a, b)+  MkD3 ::+    forall a ->+    a ->+    forall b ->+    b ->+    D (a, b)

@@ -0,0 +1,24 @@+data T a where+  Typed :: forall a -> a -> T a++f1 (Typed a x) = x :: a+f2 (Typed Int n) = n*2+f3 (Typed ((->) w Bool) g) = not . g++data D x where+  MkD1 :: forall a b ->+          a ->+          b ->+          D (a, b)++  MkD2 :: forall a.+          forall b ->+          a ->+          b ->+          D (a, b)++  MkD3 :: forall a ->+          a ->+          forall b ->+          b ->+          D (a, b)

@@ -1,5 +1,1 @@-data A-  = A-      -- | a number-      Int-      Bool+data A = A {- | a number -} Int Bool

@@ -0,0 +1,4 @@+data Buffer+    = Buffer+        {-# UNPACK #-} !(ForeignPtr Word8) -- underlying pinned array+        {-# UNPACK #-} !(Ptr Word8) -- beginning of slice

@@ -0,0 +1,4 @@+data Buffer+  = Buffer+      {-# UNPACK #-} !(ForeignPtr Word8) -- underlying pinned array+      {-# UNPACK #-} !(Ptr Word8) -- beginning of slice

@@ -0,0 +1,2 @@+data Buffer = Buffer {-# UNPACK #-} !(ForeignPtr Word8) -- underlying pinned array+                     {-# UNPACK #-} !(Ptr Word8)        -- beginning of slice

@@ -0,0 +1,4 @@+data P+    = P+        {-# UNPACK #-} !Word32 -- left word+        {-# UNPACK #-} !Word32 -- right word

@@ -0,0 +1,4 @@+data P+  = P+      {-# UNPACK #-} !Word32 -- left word+      {-# UNPACK #-} !Word32 -- right word

@@ -0,0 +1,2 @@+data P = P {-# UNPACK #-} !Word32 -- left word+           {-# UNPACK #-} !Word32 -- right word

@@ -0,0 +1,4 @@+data TBQueue a+    = TBQueue+        {-# UNPACK #-} !(TVar Natural) -- CR:  read capacity+        {-# UNPACK #-} !(TVar [a]) -- R:   elements waiting to be read

@@ -0,0 +1,4 @@+data TBQueue a+  = TBQueue+      {-# UNPACK #-} !(TVar Natural) -- CR:  read capacity+      {-# UNPACK #-} !(TVar [a]) -- R:   elements waiting to be read

@@ -0,0 +1,3 @@+data TBQueue a+   = TBQueue {-# UNPACK #-} !(TVar Natural) -- CR:  read capacity+             {-# UNPACK #-} !(TVar [a])     -- R:   elements waiting to be read

@@ -0,0 +1,4 @@+data Builder+    = Builder+        {-# UNPACK #-} !Int -- offset+        {-# UNPACK #-} !Int -- used units

@@ -0,0 +1,4 @@+data Builder+  = Builder+      {-# UNPACK #-} !Int -- offset+      {-# UNPACK #-} !Int -- used units

@@ -0,0 +1,3 @@+data Builder = Builder+     {-# UNPACK #-} !Int -- offset+     {-# UNPACK #-} !Int -- used units

@@ -0,0 +1,8 @@+{-# LANGUAGE MultilineStrings #-}++foreign import capi+    """+    foo+       bar+    """+    foo :: Int -> Int

@@ -0,0 +1,8 @@+{-# LANGUAGE MultilineStrings #-}++foreign import capi+  """+  foo+     bar+  """+  foo :: Int -> Int

@@ -0,0 +1,6 @@+{-# language MultilineStrings #-}++foreign import capi """+         foo+            bar+     """ foo :: Int -> Int

@@ -11,7 +11,7 @@ -- when we disable the rule that expands (++) into foldr  -- The foldr/cons rule looks nice, but it can give disastrously--- bloated code when commpiling+-- bloated code when compiling --      array (a,b) [(1,2), (2,2), (3,2), ...very long list... ] -- i.e. when there are very very long literal lists -- So I've disabled it for now. We could have special cases

@@ -11,7 +11,7 @@ -- when we disable the rule that expands (++) into foldr  -- The foldr/cons rule looks nice, but it can give disastrously--- bloated code when commpiling+-- bloated code when compiling --      array (a,b) [(1,2), (2,2), (3,2), ...very long list... ] -- i.e. when there are very very long literal lists -- So I've disabled it for now. We could have special cases

@@ -11,7 +11,7 @@         -- when we disable the rule that expands (++) into foldr  -- The foldr/cons rule looks nice, but it can give disastrously--- bloated code when commpiling+-- bloated code when compiling --      array (a,b) [(1,2), (2,2), (3,2), ...very long list... ] -- i.e. when there are very very long literal lists -- So I've disabled it for now. We could have special cases

@@ -2,6 +2,7 @@ "unpack" [~1] forall a. unpackCString # a = build (unpackFoldrCString # a) "unpack-list" [1] forall a. unpackFoldrCString # a (:) [] = unpackCString # a "unpack-append" forall a n. unpackFoldrCString # a (:) n = unpackAppendCString # a n+ -- There's a built-in rule (in PrelRules.lhs) for --      unpackFoldr "foo" c (unpackFoldr "baz" c n)  =  unpackFoldr "foobaz" c n     #-}

@@ -2,6 +2,7 @@ "unpack" [~1] forall a. unpackCString # a = build (unpackFoldrCString # a) "unpack-list" [1] forall a. unpackFoldrCString # a (:) [] = unpackCString # a "unpack-append" forall a n. unpackFoldrCString # a (:) n = unpackAppendCString # a n+ -- There's a built-in rule (in PrelRules.lhs) for --      unpackFoldr "foo" c (unpackFoldr "baz" c n)  =  unpackFoldr "foobaz" c n   #-}

@@ -0,0 +1,8 @@+{-# SPECIALIZE addMult @Double #-}+{-# SPECIALIZE addMult (5 :: Int) #-}+{-# SPECIALIZE addMult 5 :: Int -> Int #-}++{-# SPECIALIZE [1] forall x y. f @Int True (x, y) #-}++{-# SPECIALIZE forall x xs. loop (x : xs)+    #-}

@@ -0,0 +1,8 @@+{-# SPECIALIZE addMult @Double #-}+{-# SPECIALIZE addMult (5 :: Int) #-}+{-# SPECIALIZE addMult 5 :: Int -> Int #-}++{-# SPECIALIZE [1] forall x y. f @Int True (x, y) #-}++{-# SPECIALIZE forall x xs. loop (x : xs)+  #-}

@@ -0,0 +1,9 @@+{-# SPECIALISE addMult @Double #-}+{-# SPECIALISE addMult (5 :: Int) #-}+{-# SPECIALISE addMult 5 :: Int -> Int #-}++{-# SPECIALISE [1] forall x y. f @Int True (x,y) #-}++{-# SPECIALISE+  forall x xs .+  loop (x:xs) #-}

@@ -0,0 +1,10 @@+sep, fsep, hsep :: (Applicative m, Foldable t) => t (m Doc) -> m Doc+sep = fmap P.sep . sequenceAFoldable+{-# SPECIALIZE NOINLINE sep :: [TCM Doc] -> TCM Doc #-}+{-# SPECIALIZE NOINLINE sep :: List1 (TCM Doc) -> TCM Doc #-}+fsep = fmap P.fsep . sequenceAFoldable+{-# SPECIALIZE NOINLINE [2] fsep :: [TCM Doc] -> TCM Doc #-}+{-# SPECIALIZE NOINLINE [2] fsep :: List1 (TCM Doc) -> TCM Doc #-}+hsep = fmap P.hsep . sequenceAFoldable+{-# SPECIALIZE NOINLINE [~2] hsep :: [TCM Doc] -> TCM Doc #-}+{-# SPECIALIZE NOINLINE [~2] hsep :: List1 (TCM Doc) -> TCM Doc #-}

@@ -0,0 +1,10 @@+sep, fsep, hsep :: (Applicative m, Foldable t) => t (m Doc) -> m Doc+sep = fmap P.sep . sequenceAFoldable+{-# SPECIALIZE NOINLINE sep :: [TCM Doc] -> TCM Doc #-}+{-# SPECIALIZE NOINLINE sep :: List1 (TCM Doc) -> TCM Doc #-}+fsep = fmap P.fsep . sequenceAFoldable+{-# SPECIALIZE NOINLINE [2] fsep :: [TCM Doc] -> TCM Doc #-}+{-# SPECIALIZE NOINLINE [2] fsep :: List1 (TCM Doc) -> TCM Doc #-}+hsep = fmap P.hsep . sequenceAFoldable+{-# SPECIALIZE NOINLINE [~2] hsep :: [TCM Doc] -> TCM Doc #-}+{-# SPECIALIZE NOINLINE [~2] hsep :: List1 (TCM Doc) -> TCM Doc #-}

@@ -0,0 +1,4 @@+sep, fsep, hsep :: (Applicative m, Foldable t) => t (m Doc) -> m Doc+sep  = fmap P.sep  . sequenceAFoldable  ; {-# SPECIALIZE NOINLINE sep  :: [TCM Doc] -> TCM Doc #-} ; {-# SPECIALIZE NOINLINE sep  :: List1 (TCM Doc) -> TCM Doc #-}+fsep = fmap P.fsep . sequenceAFoldable  ; {-# SPECIALIZE NOINLINE [2] fsep :: [TCM Doc] -> TCM Doc #-} ; {-# SPECIALIZE NOINLINE [2] fsep :: List1 (TCM Doc) -> TCM Doc #-}+hsep = fmap P.hsep . sequenceAFoldable  ; {-# SPECIALIZE NOINLINE [~2] hsep :: [TCM Doc] -> TCM Doc #-} ; {-# SPECIALIZE NOINLINE [~2] hsep :: List1 (TCM Doc) -> TCM Doc #-}

@@ -23,6 +23,5 @@     F a = String  type family F a where-    F a -- foo-        =+    F a = -- foo         a

@@ -25,6 +25,5 @@   F a = String  type family F a where-  F a -- foo-    =+  F a = -- foo     a

@@ -19,6 +19,5 @@         :<|> "route2" :> ApiRoute2 -- comment here         :<|> OmitDocs :> "i" :> ASomething API -type A -- foo-    =+type A = -- foo     B

@@ -19,6 +19,5 @@     :<|> "route2" :> ApiRoute2 -- comment here     :<|> OmitDocs :> "i" :> ASomething API -type A -- foo-  =+type A = -- foo   B

@@ -12,7 +12,7 @@                 )         -> do             -- Begin do-            (x, y) <- -- GHC parser fails if layed out over multiple lines+            (x, y) <- -- GHC parser fails if laid out over multiple lines                 f -- Call into f                     ( a                     , c -- Tuple together arguments@@ -29,8 +29,7 @@                     Left                         ( z                             , w-                            ) -> \u ->-                            -- Procs can have lambdas+                            ) -> \u -> -- Procs can have lambdas                             let                                 v =                                     u -- Actually never used

@@ -12,7 +12,7 @@         )     -> do       -- Begin do-      (x, y) <- -- GHC parser fails if layed out over multiple lines+      (x, y) <- -- GHC parser fails if laid out over multiple lines         f -- Call into f           ( a,             c -- Tuple together arguments@@ -29,8 +29,7 @@           Left             ( z,               w-              ) -> \u ->-              -- Procs can have lambdas+              ) -> \u -> -- Procs can have lambdas               let v =                     u -- Actually never used                       ^ 2

@@ -9,7 +9,7 @@         (e, f)       ) ->     do -- Begin do-        (x,y) -- GHC parser fails if layed out over multiple lines+        (x,y) -- GHC parser fails if laid out over multiple lines          <- f -- Call into f               (a,                c) -- Tuple together arguments

@@ -5,6 +5,5 @@ bar =     proc x -> \f g h ->         \() ->-            \(Left (x, y)) ->-                -- Tuple value+            \(Left (x, y)) -> -- Tuple value                 f (g (h x)) -< y

@@ -5,6 +5,5 @@ bar =   proc x -> \f g h ->     \() ->-      \(Left (x, y)) ->-        -- Tuple value+      \(Left (x, y)) -> -- Tuple value         f (g (h x)) -< y

@@ -1,6 +1,5 @@ mergeErrorReply :: ParseError -> Reply s u a -> Reply s u a-mergeErrorReply err1 reply -- XXX where to put it?-    =+mergeErrorReply err1 reply = -- XXX where to put it?     case reply of         Ok x state err2 -> Ok x state (mergeError err1 err2)         Error err2 -> Error (mergeError err1 err2)

@@ -1,6 +1,5 @@ mergeErrorReply :: ParseError -> Reply s u a -> Reply s u a-mergeErrorReply err1 reply -- XXX where to put it?-  =+mergeErrorReply err1 reply = -- XXX where to put it?   case reply of     Ok x state err2 -> Ok x state (mergeError err1 err2)     Error err2 -> Error (mergeError err1 err2)

@@ -1,8 +1,7 @@ doForeign :: Vars -> [Name] -> [Term] -> Idris LExp doForeign x = x   where-    splitArg tm | (_, [_, _, l, r]) <- unApply tm -- pair, two implicits-        =+    splitArg tm | (_, [_, _, l, r]) <- unApply tm = -- pair, two implicits         do             let l' = toFDesc l             r' <- irTerm (sMN 0 "__foreignCall") vs env r

@@ -1,8 +1,7 @@ doForeign :: Vars -> [Name] -> [Term] -> Idris LExp doForeign x = x   where-    splitArg tm | (_, [_, _, l, r]) <- unApply tm -- pair, two implicits-      =+    splitArg tm | (_, [_, _, l, r]) <- unApply tm = -- pair, two implicits       do         let l' = toFDesc l         r' <- irTerm (sMN 0 "__foreignCall") vs env r

@@ -0,0 +1,3 @@+foo = case a of+    b -> -- comment+        c

@@ -0,0 +1,3 @@+foo = case a of+  b -> -- comment+    c

@@ -0,0 +1,3 @@+foo = case a of+  b -- comment+    -> c

@@ -0,0 +1,6 @@+foo =+    case x of+        _ -> 1+  -- comment+  where+    x = 1

@@ -0,0 +1,6 @@+foo =+  case x of+    _ -> 1+  -- comment+  where+    x = 1

@@ -0,0 +1,6 @@+foo =+  case x of+    _ -> 1+    -- comment+    where+      x = 1

@@ -21,7 +21,6 @@ quux x = case x of     x -> x -funnyComment =-    -- comment+funnyComment = -- comment     case () of         () -> ()

@@ -21,7 +21,6 @@ quux x = case x of   x -> x -funnyComment =-  -- comment+funnyComment = -- comment   case () of     () -> ()

@@ -0,0 +1,2 @@+getValue :: Maybe Int -> Int+getValue x = case x of Just n -> n; Nothing -> 0

@@ -0,0 +1,2 @@+getValue :: Maybe Int -> Int+getValue x = case x of Just n -> n; Nothing -> 0

@@ -0,0 +1,2 @@+getValue :: Maybe Int -> Int+getValue x = case x of {Just n -> n; Nothing -> 0}

@@ -0,0 +1,14 @@+foo =+    case x of+        _ -> 1+  -- comment+  where+    -- comment 2+    x = 1++foo = case x of+    _ -> 1+  -- comment+  where+    -- comment 2+    x = 1

@@ -0,0 +1,14 @@+foo =+  case x of+    _ -> 1+  -- comment+  where+    -- comment 2+    x = 1++foo = case x of+  _ -> 1+  -- comment+  where+    -- comment 2+    x = 1

@@ -0,0 +1,14 @@+foo =+  case x of+    _ -> 1+    -- comment+    where+      -- comment 2+      x = 1++foo = case x of+    _ -> 1+    -- comment+    where+      -- comment 2+      x = 1

@@ -0,0 +1,13 @@+handleInput :: IO ()+handleInput = do+    putStrLn "Enter command:"+    cmd <- getLine+    case cmd of+        "quit" -> putStrLn "Goodbye"+        "help" -> do+            putStrLn "Available commands:"+            putStrLn "  quit - exit the program"+            putStrLn "  help - show this message"+        _ -> do+            putStrLn $ "Unknown command: " ++ cmd+            handleInput

@@ -0,0 +1,13 @@+handleInput :: IO ()+handleInput = do+  putStrLn "Enter command:"+  cmd <- getLine+  case cmd of+    "quit" -> putStrLn "Goodbye"+    "help" -> do+      putStrLn "Available commands:"+      putStrLn "  quit - exit the program"+      putStrLn "  help - show this message"+    _ -> do+      putStrLn $ "Unknown command: " ++ cmd+      handleInput

@@ -0,0 +1,13 @@+handleInput :: IO ()+handleInput = do+  putStrLn "Enter command:"+  cmd <- getLine+  case cmd of+    "quit" -> putStrLn "Goodbye"+    "help" -> do+      putStrLn "Available commands:"+      putStrLn "  quit - exit the program"+      putStrLn "  help - show this message"+    _ -> do+      putStrLn $ "Unknown command: " ++ cmd+      handleInput

@@ -0,0 +1,2 @@+checkValue :: Int -> IO ()+checkValue n = do putStr "Value is: "; case () of { _ | n < 0 -> putStrLn "negative" | n == 0 -> putStrLn "zero" | otherwise -> putStrLn "positive" }

@@ -0,0 +1,2 @@+checkValue :: Int -> IO ()+checkValue n = do putStr "Value is: "; case () of { _ | n < 0 -> putStrLn "negative" | n == 0 -> putStrLn "zero" | otherwise -> putStrLn "positive" }

@@ -0,0 +1,2 @@+checkValue :: Int -> IO ()+checkValue n = do {putStr "Value is: "; case () of {_ | n < 0 -> putStrLn "negative" | n == 0 -> putStrLn "zero" | otherwise -> putStrLn "positive"}}

@@ -0,0 +1,2 @@+processValue :: Maybe Int -> IO ()+processValue x = do putStrLn "Processing:"; \case { Just n -> print n; Nothing -> putStrLn "Empty" } x; putStrLn "Done"

@@ -0,0 +1,2 @@+processValue :: Maybe Int -> IO ()+processValue x = do putStrLn "Processing:"; \case { Just n -> print n; Nothing -> putStrLn "Empty" } x; putStrLn "Done"

@@ -0,0 +1,2 @@+processValue :: Maybe Int -> IO ()+processValue x = do {putStrLn "Processing:"; \case {Just n -> print n; Nothing -> putStrLn "Empty"} x; putStrLn "Done"}

@@ -0,0 +1,2 @@+processPair :: Maybe Int -> Maybe String -> IO ()+processPair x y = do case x of { Just n -> print n; Nothing -> putStrLn "No number" }; case y of { Just s -> putStrLn s; Nothing -> putStrLn "No string" }

@@ -0,0 +1,2 @@+processPair :: Maybe Int -> Maybe String -> IO ()+processPair x y = do case x of { Just n -> print n; Nothing -> putStrLn "No number" }; case y of { Just s -> putStrLn s; Nothing -> putStrLn "No string" }

@@ -0,0 +1,2 @@+processPair :: Maybe Int -> Maybe String -> IO ()+processPair x y = do {case x of {Just n -> print n; Nothing -> putStrLn "No number"}; case y of {Just s -> putStrLn s; Nothing -> putStrLn "No string"}}

@@ -0,0 +1,2 @@+nestedDo :: Either String Int -> IO ()+nestedDo e = do putStr "Start: "; case e of { Left s -> do { putStr "Error: "; putStrLn s }; Right n -> do { putStr "Value: "; print n } }; putStrLn "End"

@@ -0,0 +1,2 @@+nestedDo :: Either String Int -> IO ()+nestedDo e = do putStr "Start: "; case e of { Left s -> do { putStr "Error: "; putStrLn s }; Right n -> do { putStr "Value: "; print n } }; putStrLn "End"

@@ -0,0 +1,2 @@+nestedDo :: Either String Int -> IO ()+nestedDo e = do {putStr "Start: "; case e of {Left s -> do {putStr "Error: "; putStrLn s}; Right n -> do {putStr "Value: "; print n}}; putStrLn "End"}

@@ -0,0 +1,2 @@+doGuessing :: (Ord t, Read t) => t -> IO ()+doGuessing num = do putStrLn "Enter your guess:"; guess <- getLine; case compare (read guess) num of { LT -> do { putStrLn "Too low!"; doGuessing num }; GT -> do { putStrLn "Too high!"; doGuessing num }; EQ -> putStrLn "You win!" }

@@ -0,0 +1,2 @@+doGuessing :: (Ord t, Read t) => t -> IO ()+doGuessing num = do putStrLn "Enter your guess:"; guess <- getLine; case compare (read guess) num of { LT -> do { putStrLn "Too low!"; doGuessing num }; GT -> do { putStrLn "Too high!"; doGuessing num }; EQ -> putStrLn "You win!" }

@@ -0,0 +1,2 @@+doGuessing :: (Ord t, Read t) => t -> IO ()+doGuessing num = do {putStrLn "Enter your guess:"; guess <- getLine; case compare (read guess) num of {LT -> do {putStrLn "Too low!"; doGuessing num}; GT -> do { putStrLn "Too high!"; doGuessing num}; EQ -> putStrLn "You win!"}}

@@ -10,3 +10,5 @@ quux :: Int -> Int quux x | x < 0 = x quux x = x++(a, b) | c = d

@@ -10,3 +10,5 @@ quux :: Int -> Int quux x | x < 0 = x quux x = x++(a, b) | c = d

@@ -10,3 +10,5 @@ quux :: Int -> Int quux x | x < 0 = x quux x = x++(a, b) | c = d

@@ -13,9 +13,9 @@         throwIO (OrmoluCppEnabled path)  foo =-    bar $-        baz $-            quux+    bar+        $ baz+        $ quux  x =     case l of { A -> B } $

@@ -13,9 +13,9 @@     throwIO (OrmoluCppEnabled path)  foo =-  bar $-    baz $-      quux+  bar+    $ baz+    $ quux  x =   case l of { A -> B } $

@@ -1,11 +1,11 @@ ex1 =-    f1 $-        arg1 $-            arg2 $-                arg3+    f1+        $ arg1+        $ arg2+        $ arg3  ex3 =-    f1 $-        arg1 $-            arg2 $-                1 + 3+    f1+        $ arg1+        $ arg2+        $ 1 + 3

@@ -1,11 +1,11 @@ ex1 =-  f1 $-    arg1 $-      arg2 $-        arg3+  f1+    $ arg1+    $ arg2+    $ arg3  ex3 =-  f1 $-    arg1 $-      arg2 $-        1 + 3+  f1+    $ arg1+    $ arg2+    $ 1 + 3

@@ -1,5 +1,5 @@ ex2 =-    f1 $-        arg1 $-            arg2 $-                f2 arg3+    f1+        $ arg1+        $ arg2+        $ f2 arg3

@@ -1,5 +1,5 @@ ex2 =-  f1 $-    arg1 $-      arg2 $-        f2 arg3+  f1+    $ arg1+    $ arg2+    $ f2 arg3

@@ -1,14 +1,14 @@ import Control.Lens  lenses =-    Just $-        M.fromList $-            "type" .= ("user.connection" :: Text)-                # "connection" .= uc-                # "user" .= case name of-                    Just n -> Just $ object ["name" .= n]-                    Nothing -> Nothing-                # []+    Just+        $ M.fromList+        $ "type" .= ("user.connection" :: Text)+            # "connection" .= uc+            # "user" .= case name of+                Just n -> Just $ object ["name" .= n]+                Nothing -> Nothing+            # []  foo =     a

@@ -1,14 +1,14 @@ import Control.Lens  lenses =-  Just $-    M.fromList $-      "type" .= ("user.connection" :: Text)-        # "connection" .= uc-        # "user" .= case name of-          Just n -> Just $ object ["name" .= n]-          Nothing -> Nothing-        # []+  Just+    $ M.fromList+    $ "type" .= ("user.connection" :: Text)+      # "connection" .= uc+      # "user" .= case name of+        Just n -> Just $ object ["name" .= n]+        Nothing -> Nothing+      # []  foo =   a

@@ -1,11 +1,11 @@ -- Right chain, $ case, 2 operators with p($) == p(b) n :: Int n =-    1 $-        2 $-            3 $-                4 `seq`-                    5 $-                        6 $-                            7 $-                                8+    1+        $ 2+        $ 3+        $ 4+        `seq` 5+        $ 6+        $ 7+        $ 8

@@ -1,11 +1,11 @@ -- Right chain, $ case, 2 operators with p($) == p(b) n :: Int n =-  1 $-    2 $-      3 $-        4 `seq`-          5 $-            6 $-              7 $-                8+  1+    $ 2+    $ 3+    $ 4+    `seq` 5+    $ 6+    $ 7+    $ 8

@@ -1,11 +1,11 @@ -- Right chain, $ case, 2 operators with p(a) == p($) p :: Int p =-    1 `seq`-        2 `seq`-            3 `seq`-                4 $-                    5 `seq`-                        6 `seq`-                            7 `seq`-                                8+    1+        `seq` 2+        `seq` 3+        `seq` 4+        $ 5+        `seq` 6+        `seq` 7+        `seq` 8

@@ -1,11 +1,11 @@ -- Right chain, $ case, 2 operators with p(a) == p($) p :: Int p =-  1 `seq`-    2 `seq`-      3 `seq`-        4 $-          5 `seq`-            6 `seq`-              7 `seq`-                8+  1+    `seq` 2+    `seq` 3+    `seq` 4+    $ 5+    `seq` 6+    `seq` 7+    `seq` 8

@@ -1,7 +1,7 @@ -- Right chain, $ case, 1 operator type c :: Int c =-    1 $-        2 $-            3 $-                4+    1+        $ 2+        $ 3+        $ 4

@@ -1,7 +1,7 @@ -- Right chain, $ case, 1 operator type c :: Int c =-  1 $-    2 $-      3 $-        4+  1+    $ 2+    $ 3+    $ 4

@@ -1,9 +1,9 @@ lenses =-    Just $-        M.fromList $-            "type" Foo..= ("user.connection" :: Text)-                Bar.# "connection" Foo..= uc-                Bar.# "user" Foo..= case name of-                    Just n -> Just $ object ["name" .= n]-                    Nothing -> Nothing-                Bar.# []+    Just+        $ M.fromList+        $ "type" Foo..= ("user.connection" :: Text)+            Bar.# "connection" Foo..= uc+            Bar.# "user" Foo..= case name of+                Just n -> Just $ object ["name" .= n]+                Nothing -> Nothing+            Bar.# []

@@ -1,9 +1,9 @@ lenses =-  Just $-    M.fromList $-      "type" Foo..= ("user.connection" :: Text)-        Bar.# "connection" Foo..= uc-        Bar.# "user" Foo..= case name of-          Just n -> Just $ object ["name" .= n]-          Nothing -> Nothing-        Bar.# []+  Just+    $ M.fromList+    $ "type" Foo..= ("user.connection" :: Text)+      Bar.# "connection" Foo..= uc+      Bar.# "user" Foo..= case name of+        Just n -> Just $ object ["name" .= n]+        Nothing -> Nothing+      Bar.# []

@@ -0,0 +1,2 @@+f = \a -> -- foo+    a

@@ -0,0 +1,2 @@+f = \a -> -- foo+  a

@@ -0,0 +1,2 @@+f = \a -> -- foo+  a

@@ -0,0 +1,9 @@+{-# LANGUAGE LinearTypes #-}++h x = g y+  where+    %1 y = f x++let %1 x = u in ()+let %Many (x, y) = u in ()+let %1 ~(x, y) = u in ()

@@ -0,0 +1,9 @@+{-# LANGUAGE LinearTypes #-}++h x = g y+  where+    %1 y = f x++let %1 x = u in ()+let %Many (x, y) = u in ()+let %1 ~(x, y) = u in ()

@@ -0,0 +1,9 @@+{-# Language LinearTypes #-}++h x = g y+  where+    %1 y = f x++let %1 x = u in ()+let %Many (x, y) = u in ()+let %1 ~(x, y) = u in ()

@@ -0,0 +1,11 @@+{-# LANGUAGE MultilineStrings #-}++multilineBlank =+    """+    1+++++    6+    """

@@ -0,0 +1,11 @@+{-# LANGUAGE MultilineStrings #-}++multilineBlank =+  """+  1+++++  6+  """

@@ -0,0 +1,11 @@+{-# LANGUAGE MultilineStrings #-}++multilineBlank =+  """+  1+++++  6+  """

@@ -4,7 +4,6 @@  function' :: String -> String function' s = case s of-    "ThisString" ->-        -- And a comment here is okay+    "ThisString" -> -- And a comment here is okay         "Yay"     _ -> "Boo"

@@ -4,7 +4,6 @@  function' :: String -> String function' s = case s of-  "ThisString" ->-    -- And a comment here is okay+  "ThisString" -> -- And a comment here is okay     "Yay"   _ -> "Boo"

@@ -0,0 +1,5 @@+data X = X {x :: Int}++f =+    id+        . (\s -> s{x = 1}) -- Some comment

@@ -0,0 +1,5 @@+data X = X {x :: Int}++f =+  id+    . (\s -> s {x = 1}) -- Some comment

@@ -0,0 +1,5 @@+data X = X { x :: Int }++f = id+    . -- Some comment+    (\s -> s { x = 1 })

@@ -0,0 +1,4 @@+foo = do+    bar+        -- txt+        $ baz

@@ -0,0 +1,4 @@+foo = do+  bar+    -- txt+    $ baz

@@ -0,0 +1,4 @@+foo = do+  bar+    -- txt+    $ baz

@@ -20,7 +20,8 @@ sane e = case e of     1     2-    3 -> a+    3 ->+        a     4     5     6 -> b@@ -33,3 +34,10 @@     (D; E (Just _) Nothing) ->         4     F -> 5++food+    foo@( A;+            B;+            C+            ) = Just foo+food _ = Nothing

@@ -21,7 +21,8 @@ sane e = case e of   1   2-  3 -> a+  3 ->+    a   4   5   6 -> b@@ -34,3 +35,10 @@   (D; E (Just _) Nothing) ->     4   F -> 5++food+  foo@( A;+        B;+        C+        ) = Just foo+food _ = Nothing

@@ -20,7 +20,8 @@ sane e = case e of   1   2-  3 -> a+  3 ->+    a   4   5;6 -> b   7;8 -> c@@ -31,3 +32,8 @@   (D; E (Just _) Nothing)    -> 4   F -> 5++food foo@(A;+          B;+          C) = Just foo+food _ = Nothing

@@ -0,0 +1,12 @@+{-# LANGUAGE RecordWildCards #-}++example =+    Record+        { -- A+          field = () -- B+          -- C+        , field = () -- D+        -- E+        -- F+        , ..+        } -- G

@@ -0,0 +1,12 @@+{-# LANGUAGE RecordWildCards #-}++example =+  Record+    { -- A+      field = (), -- B+      -- C+      field = (), -- D+      -- E+      -- F+      ..+    } -- G

@@ -0,0 +1,11 @@+{-# LANGUAGE RecordWildCards #-}++example =+  Record+    { -- A+      field = (), -- B+      -- C+      field = (), -- D+      -- E+      .. -- F+    } -- G

@@ -0,0 +1,12 @@+{-# LANGUAGE RecordWildCards #-}++example =+    Record+        { -- A+          field = ()+        , -- C+          field = ()+          -- E+          -- F+        , ..+        } -- G

@@ -0,0 +1,12 @@+{-# LANGUAGE RecordWildCards #-}++example =+  Record+    { -- A+      field = (),+      -- C+      field = (),+      -- E+      -- F+      ..+    } -- G

@@ -0,0 +1,11 @@+{-# LANGUAGE RecordWildCards #-}++example =+  Record+    { -- A+      field = (),+      -- C+      field = (),+      -- E+      .. -- F+    } -- G

@@ -8,3 +8,5 @@     \baz"  weirdGap = "\65\ \0"++weirdEscape = "\^\ "

@@ -10,3 +10,5 @@   \baz"  weirdGap = "\65\ \0"++weirdEscape = "\^\ "

@@ -7,3 +7,5 @@     \baz"  weirdGap = "\65\ \0"++weirdEscape = "\^\ "

@@ -3,19 +3,19 @@ pattern P a <- C a where P a = C a  pattern HeadC x <- x : xs-    where-        HeadC x = [x]+  where+    HeadC x = [x]  pattern HeadC' x <-     x : xs-    where-        HeadC' x = [x]+  where+    HeadC' x = [x]  pattern Simple <- "Simple"-    where-        Simple = "Complicated"+  where+    Simple = "Complicated"  pattern a :< b <-     (a, b)-    where-        a :< b = (a, b)+  where+    a :< b = (a, b)

@@ -0,0 +1,8 @@+module MegaparsecExample where++import Text.Megaparsec++pValue =+    Object <$> parseObjectBody+        <|> Array <$> parseArrayBody+        <|> String <$> parseStringBody

@@ -0,0 +1,8 @@+module MegaparsecExample where++import Text.Megaparsec++pValue =+  Object <$> parseObjectBody+    <|> Array <$> parseArrayBody+    <|> String <$> parseStringBody

@@ -0,0 +1,8 @@+module MegaparsecExample where++import Text.Megaparsec++pValue =+  Object <$> parseObjectBody+    <|> Array <$> parseArrayBody+    <|> String <$> parseStringBody

@@ -0,0 +1,8 @@+module OpticsExample where++import Optics++updated =+    record+        & fieldLens % subFieldLens .~ someValue+        & otherLens %~ someTransformationFunctionApplied

@@ -0,0 +1,8 @@+module OpticsExample where++import Optics++updated =+  record+    & fieldLens % subFieldLens .~ someValue+    & otherLens %~ someTransformationFunctionApplied

@@ -0,0 +1,8 @@+module OpticsExample where++import Optics++updated =+  record+    & fieldLens % subFieldLens .~ someValue+    & otherLens %~ someTransformationFunctionApplied

@@ -0,0 +1,10 @@+module ReludeChainExample where++import Relude++resolveValue =+    primarySource+        ?: secondarySource+        ?: tertiarySource+        ?: quaternarySource+        ?: finalFallbackValue

@@ -0,0 +1,10 @@+module ReludeChainExample where++import Relude++resolveValue =+  primarySource+    ?: secondarySource+    ?: tertiarySource+    ?: quaternarySource+    ?: finalFallbackValue

@@ -0,0 +1,10 @@+module ReludeChainExample where++import Relude++resolveValue =+  primarySource+    ?: secondarySource+    ?: tertiarySource+    ?: quaternarySource+    ?: finalFallbackValue

@@ -0,0 +1,7 @@+module ReludeExample where++import Relude++config =+    lookupOptionalSetting environment ?:+        defaultConfigurationValue

@@ -0,0 +1,7 @@+module ReludeExample where++import Relude++config =+  lookupOptionalSetting environment ?:+    defaultConfigurationValue

@@ -0,0 +1,7 @@+module ReludeExample where++import Relude++config =+  lookupOptionalSetting environment+    ?: defaultConfigurationValue

@@ -0,0 +1,7 @@+module RioExample where++import RIO++message =+    greetingText <> userNameText+        & Text.strip

@@ -0,0 +1,7 @@+module RioExample where++import RIO++message =+  greetingText <> userNameText+    & Text.strip

@@ -0,0 +1,7 @@+module RioExample where++import RIO++message =+  greetingText <> userNameText+    & Text.strip

@@ -0,0 +1,7 @@+module RioDeepseqExample where++import RIO++result =+    forceEvaluationOfBigStructure `deepseq`+        continueWithNextStep

@@ -0,0 +1,7 @@+module RioDeepseqExample where++import RIO++result =+  forceEvaluationOfBigStructure `deepseq`+    continueWithNextStep

@@ -0,0 +1,7 @@+module RioDeepseqExample where++import RIO++result =+  forceEvaluationOfBigStructure+    `deepseq` continueWithNextStep

@@ -0,0 +1,7 @@+-- their own formatters.+import Test.Hspec.Core.Formatters.V1.Monad (+    FormatM,+    Formatter (..),+ )++import Test.Hspec.Core.Formatters.V1.Monad (Item (..), interpretWith)

@@ -0,0 +1,7 @@+-- their own formatters.+import Test.Hspec.Core.Formatters.V1.Monad+  ( FormatM,+    Formatter (..),+    Item (..),+    interpretWith,+  )

@@ -0,0 +1,7 @@+-- their own formatters.+import Test.Hspec.Core.Formatters.V1.Monad (+    Formatter(..)+  , FormatM+  )++import Test.Hspec.Core.Formatters.V1.Monad (Item(..), interpretWith)

@@ -0,0 +1,7 @@+-- Import stuff from Prelude explicitly+import Prelude (+    Eq (..),+    Int,+    ($),+    (.),+ )

@@ -0,0 +1,7 @@+-- Import stuff from Prelude explicitly+import Prelude+  ( Eq (..),+    Int,+    ($),+    (.),+  )

@@ -0,0 +1,3 @@+-- Import stuff from Prelude explicitly+import Prelude (Eq(..), Int)+import Prelude ((.), ($))

@@ -0,0 +1,6 @@+import HscMain (newHscEnv)+-- Implementations of the various modes+import LoadIface (showIface)++-- Imports for --abi-hash+import LoadIface (loadUserInterface)

@@ -0,0 +1,7 @@+import HscMain (newHscEnv)+-- Implementations of the various modes+import LoadIface+  ( -- Imports for --abi-hash+    loadUserInterface,+    showIface,+  )

@@ -0,0 +1,6 @@+-- Implementations of the various modes+import           LoadIface ( showIface )+import           HscMain ( newHscEnv )++-- Imports for --abi-hash+import           LoadIface ( loadUserInterface )

@@ -0,0 +1,6 @@+import Package1+import Package2+import Package3 (++    -- , import1+ )

@@ -0,0 +1,6 @@+import Package1+import Package2+import Package3+  (+  -- , import1+  )

@@ -0,0 +1,5 @@+import Package1+import Package3 (+ -- , import1+ )+import Package2

@@ -0,0 +1,7 @@+import Package1+import Package2+import Package3 (+    hi,+    -- , import1+    test,+ )

@@ -0,0 +1,7 @@+import Package1+import Package2+import Package3+  ( hi,+    -- , import1+    test,+  )

@@ -0,0 +1,7 @@+import Package1+import Package3 (+ hi,+ -- , import1+ test,+ )+import Package2

@@ -1,7 +1,6 @@--- x- import qualified -- x   Bar import qualified -- x   Baz-import Foo+import -- x+  Foo

@@ -1,4 +1,3 @@--- (1) import Bar -- (2) import Baz -- (3)-import Foo+import Foo -- (1)

@@ -1,4 +1,3 @@--- (1) import Bar -- (2) import Baz -- (3)-import Foo+import Foo -- (1)

@@ -0,0 +1,7 @@+module Bar (data P, T (data P), data f) where++import N (+    T (data P),+    data P,+    data f,+ )

@@ -0,0 +1,7 @@+module Bar (data P, T (data P), data f) where++import N+  ( T (data P),+    data P,+    data f,+  )

@@ -0,0 +1,6 @@++module Bar (data P, T(data P), data f) where++import N (data P)+import N (T(data P))+import N (data f)

@@ -1,7 +1,5 @@ import qualified MegaModule as M (-    -- (1)-    -- (2)     Either, -- (3)-    (<<<),-    (>>>),+    (<<<), -- (2)+    (>>>), -- (1)  )

@@ -1,7 +1,5 @@ import qualified MegaModule as M-  ( -- (1)-    -- (2)-    Either, -- (3)-    (<<<),-    (>>>),+  ( Either, -- (3)+    (<<<), -- (2)+    (>>>), -- (1)   )

@@ -0,0 +1,16 @@+{-# LANGUAGE ExplicitLevelImports #-}++import A splice+import {-# SOURCE #-} safe qualified A splice as QA hiding (a, b, c, d, e, f)+import quote qualified B as QB+import qualified C splice as SC+import qualified D splice+import Data.ByteString (e)+import Data.ByteString.Lazy quote (d)+import splice Data.Text (a, b, c)+import PyF ()+import splice PyF (+    fmt,+    tmf,+ )+import quote PyF (abc)

@@ -0,0 +1,16 @@+{-# LANGUAGE ExplicitLevelImports #-}++import A splice+import {-# SOURCE #-} safe qualified A splice as QA hiding (a, b, c, d, e, f)+import quote qualified B as QB+import qualified C splice as SC+import qualified D splice+import Data.ByteString (e)+import Data.ByteString.Lazy quote (d)+import splice Data.Text (a, b, c)+import PyF ()+import splice PyF+  ( fmt,+    tmf,+  )+import quote PyF (abc)

@@ -0,0 +1,5 @@+{-# LANGUAGE ExplicitLevelImports #-}+{-# LANGUAGE ImportQualifiedPost #-}++import quote A qualified as QA+import B quote qualified as QB

@@ -0,0 +1,5 @@+{-# LANGUAGE ExplicitLevelImports #-}+{-# LANGUAGE ImportQualifiedPost #-}++import quote A qualified as QA+import B quote qualified as QB

@@ -0,0 +1,5 @@+{-# LANGUAGE ExplicitLevelImports #-}+{-# LANGUAGE ImportQualifiedPost #-}++import qualified B quote as QB+import quote qualified A as QA

@@ -0,0 +1,14 @@+{-# LANGUAGE ExplicitLevelImports #-}++import splice Data.Text (a, b, c)+import Data.ByteString.Lazy quote (d)+import Data.ByteString (e)+import {-# SOURCE #-} safe qualified A splice as QA hiding (a, b, c, d, e, f)+import quote qualified B as QB+import qualified C splice as SC+import A splice+import qualified D splice+import quote PyF (abc)+import splice PyF (fmt)+import splice PyF (tmf)+import PyF ()

@@ -0,0 +1,7 @@+{-# LANGUAGE PackageImports #-}++import "base" Control.Applicative (Alternative, (<|>))+import "base" Data.Maybe (Maybe (Nothing), maybe)+import "base" System.IO (IO)+import "yaya" Yaya.Fold (ana, cata)+import "base" Prelude ((+))

@@ -0,0 +1,7 @@+{-# LANGUAGE PackageImports #-}++import "base" Control.Applicative (Alternative, (<|>))+import "base" Data.Maybe (Maybe (Nothing), maybe)+import "base" System.IO (IO)+import "yaya" Yaya.Fold (ana, cata)+import "base" Prelude ((+))

@@ -0,0 +1,7 @@+{-# LANGUAGE PackageImports #-}++import "base" System.IO (IO)+import "base" Prelude ((+))+import "yaya" Yaya.Fold (ana, cata)+import "base" Control.Applicative (Alternative, (<|>))+import "base" Data.Maybe (Maybe (Nothing), maybe)

@@ -1,3 +1,6 @@ import Foo-import Foo (bar, foo)+import Foo (+    bar,+    foo,+ ) import Foo as F

@@ -1,3 +1,6 @@ import Foo-import Foo (bar, foo)+import Foo+  ( bar,+    foo,+  ) import Foo as F

@@ -1,2 +1,5 @@ import "bar" Foo (bar)-import "foo" Foo (baz, foo)+import "foo" Foo (+    baz,+    foo,+ )

@@ -1,2 +1,5 @@ import "bar" Foo (bar)-import "foo" Foo (baz, foo)+import "foo" Foo+  ( baz,+    foo,+  )

@@ -1,2 +1,8 @@-import Foo hiding (bar4, foo2)-import qualified Foo (bar3, foo1)+import Foo hiding (+    bar4,+    foo2,+ )+import qualified Foo (+    bar3,+    foo1,+ )

@@ -1,2 +1,8 @@-import Foo hiding (bar4, foo2)-import qualified Foo (bar3, foo1)+import Foo hiding+  ( bar4,+    foo2,+  )+import qualified Foo+  ( bar3,+    foo1,+  )

@@ -0,0 +1,6 @@+{-# LANGUAGE NoImplicitPrelude #-}++import Control.Applicative (Alternative, (<|>))+import Data.Maybe (Maybe (Nothing), maybe)+import Prelude ((+))+import System.IO (IO)

@@ -0,0 +1,6 @@+{-# LANGUAGE NoImplicitPrelude #-}++import Control.Applicative (Alternative, (<|>))+import Data.Maybe (Maybe (Nothing), maybe)+import Prelude ((+))+import System.IO (IO)

@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# LANGUAGE NoImplicitPrelude #-}++import "base" Control.Applicative (Alternative, (<|>))+import "base" Data.Maybe (Maybe (Nothing), maybe)+import "base" Prelude ((+))+import "base" System.IO (IO)+import "yaya" Yaya.Fold (ana, cata)

@@ -0,0 +1,8 @@+{-# LANGUAGE PackageImports #-}+{-# LANGUAGE NoImplicitPrelude #-}++import "base" Control.Applicative (Alternative, (<|>))+import "base" Data.Maybe (Maybe (Nothing), maybe)+import "base" Prelude ((+))+import "base" System.IO (IO)+import "yaya" Yaya.Fold (ana, cata)

@@ -0,0 +1,8 @@+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE PackageImports #-}++import "base" System.IO (IO)+import "base" Prelude ((+))+import "yaya" Yaya.Fold (ana, cata)+import "base" Control.Applicative (Alternative, (<|>))+import "base" Data.Maybe (Maybe (Nothing), maybe)

@@ -0,0 +1,6 @@+{-# LANGUAGE NoImplicitPrelude #-}++import System.IO (IO)+import Prelude ((+))+import Control.Applicative (Alternative, (<|>))+import Data.Maybe (Maybe (Nothing), maybe)

@@ -1,5 +1,13 @@ import Data.Text-import Data.Text (a, b, c)-import Data.Text hiding (a, b, c)+import Data.Text (+    a,+    b,+    c,+ )+import Data.Text hiding (+    a,+    b,+    c,+ ) import qualified Data.Text (a, b, c) import qualified Data.Text as T

@@ -1,5 +1,13 @@ import Data.Text-import Data.Text (a, b, c)-import Data.Text hiding (a, b, c)+import Data.Text+  ( a,+    b,+    c,+  )+import Data.Text hiding+  ( a,+    b,+    c,+  ) import qualified Data.Text (a, b, c) import qualified Data.Text as T

@@ -0,0 +1,4 @@+module Foo (+    -- | asdf+    foo,+) where

@@ -0,0 +1,5 @@+module Foo+  ( {- | asdf -}+    foo,+  )+where

@@ -0,0 +1,1 @@+module Foo ({- | asdf -} foo) where

@@ -1,1 +1,3 @@+-- \|+-- module Test where

@@ -1,1 +1,3 @@+-- \|+-- module Test where

@@ -0,0 +1,5 @@+checkPragma =+    ifM+        (anyM isBuiltin [builtinNat, builtinBool])+        {-then-} ok+        {-else-} notPostulate

@@ -0,0 +1,5 @@+checkPragma =+  ifM+    (anyM isBuiltin [builtinNat, builtinBool])+    {-then-} ok+    {-else-} notPostulate

@@ -0,0 +1,4 @@+checkPragma =+        ifM (anyM isBuiltin [builtinNat, builtinBool])+          {-then-} ok+          {-else-} notPostulate

@@ -0,0 +1,6 @@+eeExtensions =+    catMaybes+        [ {- 0x00 -} sniExt+        , {- 0x0a -} groupExt+        , {- 0x10 -} alpnExt+        ]

@@ -0,0 +1,6 @@+eeExtensions =+  catMaybes+    [ {- 0x00 -} sniExt,+      {- 0x0a -} groupExt,+      {- 0x10 -} alpnExt+    ]

@@ -0,0 +1,6 @@+eeExtensions =+    catMaybes+        [ {- 0x00 -} sniExt+        , {- 0x0a -} groupExt+        , {- 0x10 -} alpnExt+        ]

@@ -0,0 +1,9 @@+{-# LANGUAGE QuasiQuotes #-}++example =+    [ -- A+      [u||] -- B+      -- C+    , [u||] -- D+    -- E+    ] -- F

@@ -0,0 +1,9 @@+{-# LANGUAGE QuasiQuotes #-}++example =+  [ -- A+    [u||], -- B+    -- C+    [u||] -- D+    -- E+  ] -- F

@@ -0,0 +1,9 @@+{-# LANGUAGE QuasiQuotes #-}++example =+  [ -- A+    [u||], -- B+    -- C+    [u||] -- D+    -- E+  ] -- F

@@ -0,0 +1,3 @@+{- ***+   aaa+-}

@@ -0,0 +1,3 @@+{- ***+   aaa+-}

@@ -0,0 +1,3 @@+{- ***+   aaa+-}

@@ -1,6 +1,6 @@ module Main (main) where --- | Foo.+{- | Foo. -}  -- Bar main :: IO ()

@@ -0,0 +1,9 @@+tests_Cli_Utils =+    testGroup+        "Utils"+        [++        --  testGroup "journalApplyValue" [+        --    testCase "time" $ do+        --  ]+        ]

@@ -0,0 +1,9 @@+tests_Cli_Utils =+  testGroup+    "Utils"+    [++    --  testGroup "journalApplyValue" [+    --    testCase "time" $ do+    --  ]+    ]

@@ -0,0 +1,6 @@+tests_Cli_Utils = testGroup "Utils" [++  --  testGroup "journalApplyValue" [+  --    testCase "time" $ do+  --  ]+  ]

@@ -0,0 +1,11 @@+module Hledger.Cli.Commands where++commandsList :: String -> [String] -> [String]+commandsList progversion othercmds =+    map (bold' . accent) _banner_smslant+        ++ [ -- XXX not showing bold, why ?+             -- Keep the following synced with:+             --  commands.m4+             "----------"+           , progversion+           ]

@@ -0,0 +1,11 @@+module Hledger.Cli.Commands where++commandsList :: String -> [String] -> [String]+commandsList progversion othercmds =+  map (bold' . accent) _banner_smslant+    ++ [ -- XXX not showing bold, why ?+         -- Keep the following synced with:+         --  commands.m4+         "----------",+         progversion+       ]

@@ -0,0 +1,11 @@+module Hledger.Cli.Commands where++commandsList :: String -> [String] -> [String]+commandsList progversion othercmds =+  map (bold' . accent) _banner_smslant ++   -- XXX not showing bold, why ?+  [+  -- Keep the following synced with:+  --  commands.m4+   "----------"+  ,progversion+  ]

@@ -1,17 +1,20 @@--- |--- Module:      Data.Aeson.TH--- Copyright:   (c) 2011-2016 Bryan O'Sullivan---              (c) 2011 MailRank, Inc.--- License:     BSD3--- Stability:   experimental--- Portability: portable+{-|+Module:      Data.Aeson.TH+Copyright:   (c) 2011-2016 Bryan O'Sullivan+             (c) 2011 MailRank, Inc.+License:     BSD3+Stability:   experimental+Portability: portable+-} module Main where --- |------ Here is a snippet:------ @--- x = y + 2--- @+{- |++Here is a snippet:++@+x = y + 2+@++-} x = y + 2

@@ -0,0 +1,4 @@+doBlock = do+    a --++    b

@@ -0,0 +1,4 @@+doBlock = do+  a --++  b

@@ -0,0 +1,4 @@+doBlock = do+  a --++  b

@@ -0,0 +1,5 @@+letBlock =+    let a = a --++        b = b+     in c

@@ -0,0 +1,5 @@+letBlock =+  let a = a --++      b = b+   in c

@@ -0,0 +1,5 @@+letBlock =+  let a = a --++      b = b+   in c

@@ -0,0 +1,22 @@+textComment = do+    a -- some text++    b++blockComment = do+    a {- foo -}++    b++twoComments = do+    a --++    --++    bar++adjacentThenBlank = do+    a --+    --++    bar

@@ -0,0 +1,22 @@+textComment = do+  a -- some text++  b++blockComment = do+  a {- foo -}++  b++twoComments = do+  a --++  --++  bar++adjacentThenBlank = do+  a --+  --++  bar

@@ -0,0 +1,22 @@+textComment = do+  a -- some text++  b++blockComment = do+  a {- foo -}++  b++twoComments = do+  a --++  --++  bar++adjacentThenBlank = do+  a --+  --++  bar

@@ -0,0 +1,5 @@+whereBlock = foo+  where+    a = a --++    b = b

@@ -0,0 +1,5 @@+whereBlock = foo+  where+    a = a --++    b = b

@@ -0,0 +1,5 @@+whereBlock = foo+  where+    a = a --++    b = b

@@ -0,0 +1,25 @@+noBlankAfterComment = do+    a --+    b++noBlankTextComment = do+    a -- some text+    b++noBlankBlockComment = do+    a {- foo -}+    b++blockCommentFollowedByExpr = do+    a {- foo -} 1+    b++whereNoBlank = foo+  where+    a = a --+    b = b++letNoBlank =+    let a = a --+        b = b+     in c

@@ -0,0 +1,25 @@+noBlankAfterComment = do+  a --+  b++noBlankTextComment = do+  a -- some text+  b++noBlankBlockComment = do+  a {- foo -}+  b++blockCommentFollowedByExpr = do+  a {- foo -} 1+  b++whereNoBlank = foo+  where+    a = a --+    b = b++letNoBlank =+  let a = a --+      b = b+   in c

@@ -0,0 +1,25 @@+noBlankAfterComment = do+  a --+  b++noBlankTextComment = do+  a -- some text+  b++noBlankBlockComment = do+  a {- foo -}+  b++blockCommentFollowedByExpr = do+  a {- foo -} 1+  b++whereNoBlank = foo+  where+    a = a --+    b = b++letNoBlank =+  let a = a --+      b = b+   in c

@@ -0,0 +1,15 @@+-- Excessive backslashes in multi line:+{-+*+|+-}++test = do+    -- Maybe excessive in single line:+    -- \* (if there's nothing after the * the line is completely dropped)+    line1+    -- Maybe excessive in multi line:+    {- \| is this excessive?+    * no excessive here at least+    -}+    line2

@@ -0,0 +1,15 @@+-- Excessive backslashes in multi line:+{-+*+|+-}++test = do+  -- Maybe excessive in single line:+  -- \* (if there's nothing after the * the line is completely dropped)+  line1+  -- Maybe excessive in multi line:+  {- \| is this excessive?+  * no excessive here at least+  -}+  line2

@@ -0,0 +1,15 @@+-- Excessive backslashes in multi line:+{-+*+|+-}++test = do+  -- Maybe excessive in single line:+  -- * (if there's nothing after the * the line is completely dropped)+  line1+  -- Maybe excessive in multi line:+  {- | is this excessive?+  * no excessive here at least+  -}+  line2

@@ -2,7 +2,8 @@ newNames =     let (*) = flip (,)      in [ "Control" * "Monad"-    -- Foo -    -- Bar+        -- Foo++        -- Bar         ]

@@ -2,7 +2,8 @@ newNames =   let (*) = flip (,)    in [ "Control" * "Monad"-  -- Foo -  -- Bar+      -- Foo++      -- Bar       ]

@@ -12,7 +12,7 @@     forall. T x = x  {-# RULES-"r"+"r" forall.     r a =         ()     #-}

@@ -12,7 +12,7 @@   forall. T x = x  {-# RULES-"r"+"r" forall.   r a =     ()   #-}

@@ -1,9 +1,13 @@+-- \| module Test (+    -- \|     test, ) where +-- \| test ::+    -- \|     test -data T = T+data T = T {- \^ -}

@@ -1,9 +1,13 @@+-- \| module Test-  ( test,+  ( -- \|+    test,   ) where +-- \| test ::+  -- \|   test -data T = T+data T = T {- \^ -}

@@ -1,5 +1,3 @@ {-# LANGUAGE TemplateHaskell #-} -foo = foo---- \|# ${+foo = foo -- \|# ${

@@ -1,5 +1,3 @@ {-# LANGUAGE TemplateHaskell #-} -foo = foo---- \|# ${+foo = foo -- \|# ${

@@ -0,0 +1,19 @@+module Plugin.Data.Spec where++{-+foo bar boz+-}+monoConstructor :: Int+monoConstructor = 1++-- hello world++-- | A type of rose trees with empty leaves.+data EmptyRose = EmptyRose [EmptyRose]++-- This seems to cause issue+{-# OPTIONS_GHC -Wno-incomplete-patterns #-}++-- bob alice eve+f :: ()+f = ()

@@ -0,0 +1,19 @@+module Plugin.Data.Spec where++{-+foo bar boz+-}+monoConstructor :: Int+monoConstructor = 1++-- hello world++-- | A type of rose trees with empty leaves.+data EmptyRose = EmptyRose [EmptyRose]++-- This seems to cause issue+{-# OPTIONS_GHC -Wno-incomplete-patterns #-}++-- bob alice eve+f :: ()+f = ()

@@ -0,0 +1,18 @@+module Plugin.Data.Spec where++{-+foo bar boz+-}+monoConstructor :: Int+monoConstructor = 1++-- hello world+-- | A type of rose trees with empty leaves.+data EmptyRose = EmptyRose [EmptyRose]++-- This seems to cause issue+{-# OPTIONS_GHC -Wno-incomplete-patterns #-}++-- bob alice eve+f :: ()+f = ()

@@ -0,0 +1,5 @@+-- comment+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}++module Foo where

@@ -0,0 +1,5 @@+-- comment+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}++module Foo where

@@ -0,0 +1,4 @@+-- comment+{-# LANGUAGE FlexibleContexts, FlexibleInstances #-}++module Foo where

@@ -0,0 +1,38 @@+-- | This is a test multiline+-- module haddock+module Foo where++-- | This is a singleline function haddock+single1 :: Int++{- | This is a singleline function haddock -}+single2 :: Int++-- | This is a multiline+-- function haddock+multi1 :: Int++{- |+This is a multiline+function haddock+-}+multi2 :: Int++{- | This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++-- | This is a haddock+--+-- with two consecutive newlines+--+--+-- https://github.com/fourmolu/fourmolu/issues/172+foo :: Int+foo = 42++-- | This is a haddock containing another haddock+--+-- > {-# LANGUAGE ScopedTypeVariables #-}+haddock_in_haddock :: Int

@@ -0,0 +1,39 @@+{- | This is a test multiline+module haddock+-}+module Foo where++-- | This is a singleline function haddock+single1 :: Int++{- | This is a singleline function haddock -}+single2 :: Int++-- | This is a multiline+-- function haddock+multi1 :: Int++{- |+This is a multiline+function haddock+-}+multi2 :: Int++{- | This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++-- | This is a haddock+--+-- with two consecutive newlines+--+--+-- https://github.com/fourmolu/fourmolu/issues/172+foo :: Int+foo = 42++-- | This is a haddock containing another haddock+--+-- > {-# LANGUAGE ScopedTypeVariables #-}+haddock_in_haddock :: Int

@@ -0,0 +1,39 @@+{-| This is a test multiline+module haddock+-}+module Foo where++-- | This is a singleline function haddock+single1 :: Int++{- | This is a singleline function haddock -}+single2 :: Int++-- | This is a multiline+-- function haddock+multi1 :: Int++{- |+This is a multiline+function haddock+-}+multi2 :: Int++{- | This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++-- | This is a haddock+--+-- with two consecutive newlines+--+--+-- https://github.com/fourmolu/fourmolu/issues/172+foo :: Int+foo = 42++-- | This is a haddock containing another haddock+--+-- > {-# LANGUAGE ScopedTypeVariables #-}+haddock_in_haddock :: Int

@@ -0,0 +1,38 @@+-- | This is a test multiline+-- module haddock+module Foo where++-- | This is a singleline function haddock+single1 :: Int++{- | This is a singleline function haddock -}+single2 :: Int++-- | This is a multiline+-- function haddock+multi1 :: Int++{- |+This is a multiline+function haddock+-}+multi2 :: Int++{- | This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++-- | This is a haddock+--+-- with two consecutive newlines+--+--+-- https://github.com/fourmolu/fourmolu/issues/172+foo :: Int+foo = 42++-- | This is a haddock containing another haddock+--+-- > {-# LANGUAGE ScopedTypeVariables #-}+haddock_in_haddock :: Int

@@ -0,0 +1,38 @@+-- | This is a test multiline+-- module haddock+module Foo where++-- | This is a singleline function haddock+single1 :: Int++{- | This is a singleline function haddock -}+single2 :: Int++-- | This is a multiline+-- function haddock+multi1 :: Int++{- |+This is a multiline+function haddock+-}+multi2 :: Int++{- | This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++-- | This is a haddock+--+-- with two consecutive newlines+--+--+-- https://github.com/fourmolu/fourmolu/issues/172+foo :: Int+foo = 42++-- | This is a haddock containing another haddock+--+-- > {-# LANGUAGE ScopedTypeVariables #-}+haddock_in_haddock :: Int

@@ -0,0 +1,41 @@+-- | This is a test multiline+-- module haddock+module Foo where++-- | This is a singleline function haddock+single1 :: Int++-- | This is a singleline function haddock+single2 :: Int++{- | This is a multiline+function haddock+-}+multi1 :: Int++{- |+This is a multiline+function haddock+-}+multi2 :: Int++{- | This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++{- | This is a haddock++with two consecutive newlines+++https://github.com/fourmolu/fourmolu/issues/172+-}+foo :: Int+foo = 42++{- | This is a haddock containing another haddock++> {-# LANGUAGE ScopedTypeVariables #-}+-}+haddock_in_haddock :: Int

@@ -37,6 +37,6 @@  {- | This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -37,6 +37,6 @@  {- | This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -36,6 +36,6 @@  {- | This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -37,6 +37,6 @@  {- | This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -0,0 +1,41 @@+-- | This is a test multiline+-- module haddock+module Foo where++-- | This is a singleline function haddock+single1 :: Int++-- | This is a singleline function haddock+single2 :: Int++{-| This is a multiline+function haddock+-}+multi1 :: Int++{-|+This is a multiline+function haddock+-}+multi2 :: Int++{-| This is a multiline haddock+     with indentation+-}+multi_indentation :: Int++{-| This is a haddock++with two consecutive newlines+++https://github.com/fourmolu/fourmolu/issues/172+-}+foo :: Int+foo = 42++{-| This is a haddock containing another haddock++> {-# LANGUAGE ScopedTypeVariables #-}+-}+haddock_in_haddock :: Int

@@ -37,6 +37,6 @@  {-| This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -37,6 +37,6 @@  {-| This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -36,6 +36,6 @@  {-| This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -37,6 +37,6 @@  {-| This is a haddock containing another haddock -> {\-# LANGUAGE ScopedTypeVariables #-\}+> {-# LANGUAGE ScopedTypeVariables #-} -} haddock_in_haddock :: Int

@@ -0,0 +1,36 @@+-- | This is a test multiline+-- module haddock+module Foo where++-- | This is a singleline function haddock+single1 :: Int++-- | This is a singleline function haddock+single2 :: Int++-- | This is a multiline+-- function haddock+multi1 :: Int++-- |+-- This is a multiline+-- function haddock+multi2 :: Int++-- | This is a multiline haddock+--      with indentation+multi_indentation :: Int++-- | This is a haddock+--+-- with two consecutive newlines+--+--+-- https://github.com/fourmolu/fourmolu/issues/172+foo :: Int+foo = 42++-- | This is a haddock containing another haddock+--+-- > {-# LANGUAGE ScopedTypeVariables #-}+haddock_in_haddock :: Int

@@ -1,13 +1,20 @@ module Main where +import Data.Either import Data.Text (Text) import Data.Maybe (maybe)  import qualified Data.Text import Control.Monad (Monad (..))+import Data.Functor  import qualified System.IO as SIO import SomeInternal.Module1 (anotherDefinition, someDefinition) import qualified SomeInternal.Module2 as Mod2 import Text.Printf (printf) import qualified SomeModule+import SomeInternal.Module2++import Foo+-- some comment+import Foo.Bar

@@ -1,9 +1,15 @@ module Main where  import Control.Monad (Monad (..))+import Data.Either+import Data.Functor import Data.Maybe (maybe) import Data.Text (Text)+import Foo+-- some comment+import Foo.Bar import SomeInternal.Module1 (anotherDefinition, someDefinition)+import SomeInternal.Module2 import Text.Printf (printf)  import qualified Data.Text

@@ -1,12 +1,18 @@ module Main where  import Control.Monad (Monad (..))+import Data.Either+import Data.Functor import Data.Maybe (maybe) import Data.Text (Text) import qualified Data.Text+import Foo+-- some comment+import Foo.Bar import qualified SomeModule import qualified System.IO as SIO import Text.Printf (printf)  import SomeInternal.Module1 (anotherDefinition, someDefinition)+import SomeInternal.Module2 import qualified SomeInternal.Module2 as Mod2

@@ -1,8 +1,13 @@ module Main where  import Control.Monad (Monad (..))+import Data.Either+import Data.Functor import Data.Maybe (maybe) import Data.Text (Text)+import Foo+-- some comment+import Foo.Bar import Text.Printf (printf)  import qualified Data.Text@@ -10,5 +15,6 @@ import qualified System.IO as SIO  import SomeInternal.Module1 (anotherDefinition, someDefinition)+import SomeInternal.Module2  import qualified SomeInternal.Module2 as Mod2

@@ -1,5 +1,12 @@ module Main where +import Data.Either+import Data.Functor+import Foo+-- some comment+import Foo.Bar+import SomeInternal.Module2+ import Data.Text (Text) import qualified Data.Text 

@@ -1,13 +1,20 @@ module Main where +import Data.Either import Data.Maybe (maybe) import Data.Text (Text)  import Control.Monad (Monad (..))+import Data.Functor import qualified Data.Text  import SomeInternal.Module1 (anotherDefinition, someDefinition)+import SomeInternal.Module2 import qualified SomeInternal.Module2 as Mod2 import qualified SomeModule import qualified System.IO as SIO import Text.Printf (printf)++import Foo+-- some comment+import Foo.Bar

@@ -1,10 +1,16 @@ module Main where  import Control.Monad (Monad (..))+import Data.Either+import Data.Functor import Data.Maybe (maybe) import Data.Text (Text) import qualified Data.Text+import Foo+-- some comment+import Foo.Bar import SomeInternal.Module1 (anotherDefinition, someDefinition)+import SomeInternal.Module2 import qualified SomeInternal.Module2 as Mod2 import qualified SomeModule import qualified System.IO as SIO

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (   asdf,   bar,@@ -21,3 +23,7 @@  class Foo a where   foo :: a -> Int++pattern HeadC x <- x : xs+  where+    HeadC x = [x]

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (   asdf,   bar,@@ -21,3 +23,7 @@  class Foo a where   foo :: a -> Int++pattern HeadC x <- x : xs+  where+    HeadC x = [x]

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (   asdf,   bar,@@ -21,3 +23,7 @@  class Foo a where   foo :: a -> Int++pattern HeadC x <- x : xs+ where+  HeadC x = [x]

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (    asdf,    bar,@@ -21,3 +23,7 @@  class Foo a where    foo :: a -> Int++pattern HeadC x <- x : xs+   where+      HeadC x = [x]

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (    asdf,    bar,@@ -21,3 +23,7 @@  class Foo a where    foo :: a -> Int++pattern HeadC x <- x : xs+  where+   HeadC x = [x]

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (     asdf,     bar,@@ -21,3 +23,7 @@  class Foo a where     foo :: a -> Int++pattern HeadC x <- x : xs+    where+        HeadC x = [x]

@@ -1,3 +1,5 @@+{-# LANGUAGE PatternSynonyms #-}+ module Foo (     asdf,     bar,@@ -21,3 +23,7 @@  class Foo a where     foo :: a -> Int++pattern HeadC x <- x : xs+  where+    HeadC x = [x]

@@ -0,0 +1,24 @@+data Foo = Foo+  { a :: Int+  , b :: Int+  , c :: Int+  }++-- Test nesting+data Client = PremiumClient { name :: String,+    address :: String, aFieldWithAnUnneccessarilyLongFieldName :: String }+  -- And some comment here as well+  | NotSoPremiumClient { name :: String,+    address :: String, aFieldWithAnUnneccessarilyLongFieldName :: String }++x :: Foo -> [Int]+x Foo{ a = possiblyLongName,+    b = anotherLongName,+    c = longNameAsWell+    } = [possiblyLongName, anotherLongName, longNameAsWell]++y :: Int -> Int -> Int -> Foo+y possiblyLongName anotherLongName longNameAsWell = Foo{ a = possiblyLongName,+    b = anotherLongName,+    c = longNameAsWell+  }

@@ -0,0 +1,35 @@+data Foo = Foo+    { a :: Int+    , b :: Int+    , c :: Int+    }++-- Test nesting+data Client+    = PremiumClient+        { name :: String+        , address :: String+        , aFieldWithAnUnneccessarilyLongFieldName :: String+        }+    | -- And some comment here as well+      NotSoPremiumClient+        { name :: String+        , address :: String+        , aFieldWithAnUnneccessarilyLongFieldName :: String+        }++x :: Foo -> [Int]+x+    Foo+        { a = possiblyLongName+        , b = anotherLongName+        , c = longNameAsWell+        } = [possiblyLongName, anotherLongName, longNameAsWell]++y :: Int -> Int -> Int -> Foo+y possiblyLongName anotherLongName longNameAsWell =+    Foo+        { a = possiblyLongName+        , b = anotherLongName+        , c = longNameAsWell+        }

@@ -0,0 +1,35 @@+data Foo = Foo+    { a :: Int,+      b :: Int,+      c :: Int+    }++-- Test nesting+data Client+    = PremiumClient+        { name :: String,+          address :: String,+          aFieldWithAnUnneccessarilyLongFieldName :: String+        }+    | -- And some comment here as well+      NotSoPremiumClient+        { name :: String,+          address :: String,+          aFieldWithAnUnneccessarilyLongFieldName :: String+        }++x :: Foo -> [Int]+x+    Foo+        { a = possiblyLongName,+          b = anotherLongName,+          c = longNameAsWell+        } = [possiblyLongName, anotherLongName, longNameAsWell]++y :: Int -> Int -> Int -> Foo+y possiblyLongName anotherLongName longNameAsWell =+    Foo+        { a = possiblyLongName,+          b = anotherLongName,+          c = longNameAsWell+        }

@@ -0,0 +1,35 @@+data Foo = Foo {+    a :: Int+    , b :: Int+    , c :: Int+    }++-- Test nesting+data Client+    = PremiumClient {+        name :: String+        , address :: String+        , aFieldWithAnUnneccessarilyLongFieldName :: String+        }+    | -- And some comment here as well+      NotSoPremiumClient {+        name :: String+        , address :: String+        , aFieldWithAnUnneccessarilyLongFieldName :: String+        }++x :: Foo -> [Int]+x+    Foo {+        a = possiblyLongName+        , b = anotherLongName+        , c = longNameAsWell+        } = [possiblyLongName, anotherLongName, longNameAsWell]++y :: Int -> Int -> Int -> Foo+y possiblyLongName anotherLongName longNameAsWell =+    Foo {+        a = possiblyLongName+        , b = anotherLongName+        , c = longNameAsWell+        }

@@ -0,0 +1,35 @@+data Foo = Foo {+    a :: Int,+    b :: Int,+    c :: Int+}++-- Test nesting+data Client+    = PremiumClient {+        name :: String,+        address :: String,+        aFieldWithAnUnneccessarilyLongFieldName :: String+    }+    | -- And some comment here as well+      NotSoPremiumClient {+        name :: String,+        address :: String,+        aFieldWithAnUnneccessarilyLongFieldName :: String+    }++x :: Foo -> [Int]+x+    Foo {+        a = possiblyLongName,+        b = anotherLongName,+        c = longNameAsWell+    } = [possiblyLongName, anotherLongName, longNameAsWell]++y :: Int -> Int -> Int -> Foo+y possiblyLongName anotherLongName longNameAsWell =+    Foo {+        a = possiblyLongName,+        b = anotherLongName,+        c = longNameAsWell+    }

@@ -7,6 +7,6 @@   deriving (ToJSON)  data B -  -- A comment that will end up in an odd place+  -- A comment that will stay above Show   deriving stock (Show)   deriving (Eq)

@@ -7,6 +7,6 @@     deriving (ToJSON)  data B-    -- A comment that will end up in an odd place+    -- A comment that will stay above Show     deriving stock (Show)     deriving (Eq)

@@ -7,7 +7,6 @@     deriving newtype (Num)  data B-    -- A comment that will end up in an odd place-     deriving (Eq)+    -- A comment that will stay above Show     deriving stock (Show)

@@ -3,11 +3,11 @@ someShortFunction $ someShortFunction $ \x -> do     putStrLn x -someLongFunction $-    someLongFunction $-        someLongFunction $-            someLongFunction $-                someLongFunction x+someLongFunction+    $ someLongFunction+    $ someLongFunction+    $ someLongFunction+    $ someLongFunction x  someLongFunction $     someLongFunction $

@@ -55,8 +55,8 @@ deconstruct (MkT1 x) = x  pattern HeadC x ← x : xs-    where-        HeadC x = [x]+  where+    HeadC x = [x]  pattern Point ∷ Int → Int → (Int, Int) pattern Point{x, y} = (x, y)

@@ -55,8 +55,8 @@ deconstruct (MkT1 x) = x  pattern HeadC x ← x : xs-    where-        HeadC x = [x]+  where+    HeadC x = [x]  pattern Point ∷ Int → Int → (Int, Int) pattern Point{x, y} = (x, y)

@@ -55,8 +55,8 @@ deconstruct (MkT1 x) = x  pattern HeadC x <- x : xs-    where-        HeadC x = [x]+  where+    HeadC x = [x]  pattern Point :: Int -> Int -> (Int, Int) pattern Point{x, y} = (x, y)

binary file changed (1002933 → 1243493 bytes)

@@ -1,12 +1,12 @@ lenses =-  Just $-    M.fromList $-      "type"-        .= ("user.connection" :: Text)-        # "connection"-        .= uc-        # "user"-        .= case name of-          Just n -> Just $ object ["name" .= n]-          Nothing -> Nothing-        # []+  Just+    $ M.fromList+    $ "type"+      .= ("user.connection" :: Text)+      # "connection"+      .= uc+      # "user"+      .= case name of+        Just n -> Just $ object ["name" .= n]+        Nothing -> Nothing+      # []

@@ -1,9 +1,9 @@ lenses =-  Just $-    M.fromList $-      "type" .= ("user.connection" :: Text)-        # "connection" .= uc-        # "user" .= case name of-          Just n -> Just $ object ["name" .= n]-          Nothing -> Nothing-        # []+  Just+    $ M.fromList+    $ "type" .= ("user.connection" :: Text)+      # "connection" .= uc+      # "user" .= case name of+        Just n -> Just $ object ["name" .= n]+        Nothing -> Nothing+      # []

@@ -1,6 +1,6 @@ cabal-version: 2.4 name: fourmolu-version: 0.19.0.1+version: 0.21.0.0 license: BSD-3-Clause license-file: LICENSE.md maintainer:@@ -8,9 +8,9 @@     George Thomas <georgefsthomas@gmail.com>     Brandon Chinn <brandonchinn178@gmail.com> tested-with:-  ghc ==9.8.4-  ghc ==9.10.1-  ghc ==9.12.1+  ghc ==9.10.3+  ghc ==9.12.4+  ghc ==9.14.1  homepage: https://github.com/fourmolu/fourmolu bug-reports: https://github.com/fourmolu/fourmolu/issues@@ -44,6 +44,9 @@ library   exposed-modules:     Ormolu+    Ormolu.Comments.Anchor+    Ormolu.Comments.Invariants+    Ormolu.Comments.Tree     Ormolu.Config     Ormolu.Diff.ParseResult     Ormolu.Diff.Text@@ -60,6 +63,7 @@     Ormolu.Parser.Result     Ormolu.Printer     Ormolu.Printer.Combinators+    Ormolu.Printer.CommentPlacement     Ormolu.Printer.Comments     Ormolu.Printer.Internal     Ormolu.Printer.Meat.Common@@ -84,8 +88,8 @@     Ormolu.Printer.Meat.Module     Ormolu.Printer.Meat.Pragma     Ormolu.Printer.Meat.Type+    Ormolu.Printer.Meat.Type.Function     Ormolu.Printer.Operators-    Ormolu.Printer.SpanStream     Ormolu.Processing.Common     Ormolu.Processing.Cpp     Ormolu.Processing.Preprocess@@ -100,8 +104,8 @@   other-modules: GHC.DynFlags   default-language: GHC2021   build-depends:-    Cabal-syntax >=3.14 && <3.15,-    Diff >=0.4 && <2,+    Cabal-syntax >=3.16 && <3.17,+    Diff >=0.4 && <2.0 || >=2.0.1 && <2.1,     MemoTrie >=0.6 && <0.7,     ansi-terminal >=0.10 && <1.2,     array >=0.5 && <0.6,@@ -109,11 +113,11 @@     binary >=0.8 && <0.9,     bytestring >=0.2 && <0.13,     choice >=0.2.4.1 && <0.3,-    containers >=0.5 && <0.8,+    containers >=0.5 && <0.9,     directory ^>=1.3,     file-embed >=0.0.15 && <0.1,     filepath >=1.2 && <1.6,-    ghc-lib-parser >=9.12 && <9.13,+    ghc-lib-parser >=9.14 && <9.15,     megaparsec >=9,     mtl >=2 && <3,     syb >=0.7 && <0.8,@@ -140,6 +144,8 @@       -Wredundant-constraints       -Wpartial-fields       -Wunused-packages+      -haddock+      -Winvalid-haddock   else     ghc-options:       -O2@@ -152,13 +158,13 @@   autogen-modules: Paths_fourmolu   default-language: GHC2021   build-depends:-    Cabal-syntax >=3.14 && <3.15,+    Cabal-syntax >=3.16 && <3.17,     base >=4.12 && <5,-    containers >=0.5 && <0.8,+    containers >=0.5 && <0.9,     directory ^>=1.3,     filepath >=1.2 && <1.6,-    ghc-lib-parser >=9.12 && <9.13,-    optparse-applicative >=0.14 && <0.19,+    ghc-lib-parser >=9.14 && <9.15,+    optparse-applicative >=0.14 && <0.20,     text >=2.1 && <3,     th-env >=0.1.1 && <0.2,     unliftio >=0.2.10 && <0.3,@@ -186,6 +192,8 @@       -Wpartial-fields       -Wunused-packages       -Wwarn=unused-packages+      -haddock+      -Winvalid-haddock   else     ghc-options:       -O2@@ -198,6 +206,7 @@   hs-source-dirs: tests   other-modules:     Ormolu.CabalInfoSpec+    Ormolu.Comments.AnchorSpec     Ormolu.Diff.TextSpec     Ormolu.Fixity.ParserSpec     Ormolu.Fixity.PrinterSpec@@ -207,17 +216,18 @@     Ormolu.Parser.ParseFailureSpec     Ormolu.Parser.PragmaSpec     Ormolu.PrinterSpec+    Ormolu.TestConfig    default-language: GHC2021   build-depends:-    Cabal-syntax >=3.14 && <3.15,+    Cabal-syntax >=3.16 && <3.17,     QuickCheck >=2.14,     base >=4.14 && <5,     choice >=0.2.4.1 && <0.3,-    containers >=0.5 && <0.8,+    containers >=0.5 && <0.9,     directory ^>=1.3,     filepath >=1.2 && <1.6,-    ghc-lib-parser >=9.12 && <9.13,+    ghc-lib-parser >=9.14 && <9.15,     hspec >=2 && <3,     hspec-megaparsec >=2.2,     megaparsec >=9,@@ -252,6 +262,8 @@       -Wredundant-constraints       -Wpartial-fields       -Wunused-packages+      -haddock+      -Winvalid-haddock   else     ghc-options:       -O2

@@ -5,12 +5,13 @@ column-limit: none function-arrows: trailing comma-style: trailing+record-style: aligned import-export-style: trailing import-grouping: legacy indent-wheres: true record-brace-space: true newlines-between-decls: 1-haddock-style: single-line+haddock-style: auto haddock-style-module: null haddock-location-signature: auto let-style: inline

@@ -7,10 +7,12 @@   ) where +import GHC.Data.FastString import GHC.Driver.Session import GHC.Platform import GHC.Settings import GHC.Settings.Config+import GHC.Unit.Types import GHC.Utils.Fingerprint  fakeSettings :: Settings@@ -43,6 +45,10 @@             platform_constants = Nothing           },       sPlatformMisc = PlatformMisc {},+      sUnitSettings =+        UnitSettings+          { unitSettings_baseUnitId = UnitId $ fsLit "ormolu"+          },       sToolSettings =         ToolSettings           { toolSettings_opt_P_fingerprint = fingerprint0,

@@ -2,7 +2,7 @@ {-# LANGUAGE RecordWildCards #-}  -- | A formatter for Haskell source code. This module exposes the official--- stable API, other modules may be not as reliable.+-- stable API; other modules may not be as reliable. module Ormolu   ( -- * Top-level formatting functions     ormolu,@@ -47,6 +47,7 @@ import Control.Exception import Control.Monad import Control.Monad.IO.Class (MonadIO (..))+import Data.Choice qualified as Choice import Data.Map.Strict qualified as Map import Data.Maybe (fromMaybe) import Data.Set qualified as Set@@ -55,9 +56,11 @@ import Data.Text.IO.Utf8 qualified as T.Utf8 import Debug.Trace import GHC.Driver.Errors.Types+import GHC.Hs (HsModule (..), locA) import GHC.Types.Error import GHC.Types.SrcLoc import GHC.Utils.Error+import Ormolu.Comments.Invariants import Ormolu.Config import Ormolu.Diff.ParseResult import Ormolu.Diff.Text@@ -73,12 +76,12 @@  -- | Format a 'Text'. ----- The function+-- The function: -----     * Needs 'IO' because some functions from GHC that are necessary to---       setup parsing context require 'IO'. There should be no visible---       side-effects though.---     * Takes file name just to use it in parse error messages.+--     * Needs 'IO' because some GHC functions that are necessary to set up+--       the parsing context require 'IO'. There should be no visible+--       side effects, though.+--     * Takes a file name only to use it in parse error messages. --     * Throws 'OrmoluException'. -- -- __NOTE__: The caller is responsible for setting the appropriate value in@@ -113,15 +116,44 @@         forM_ comments $ \(L loc comment) ->           traceM $ unwords ["*** COMMENT ***", showOutputable loc, show comment]       _ -> pure ()-  -- We're forcing 'formattedText' here because otherwise errors (such as-  -- messages about not-yet-supported functionality) will be thrown later-  -- when we try to parse the rendered code back, inside of GHC monad-  -- wrapper which will lead to error messages presenting the exceptions as-  -- GHC bugs.-  let !formattedText = printSnippets (cfgDebug cfg) result0 $ cfgPrinterOpts cfgWithIndices+  -- We force 'formattedText' here because otherwise errors (such as+  -- messages about not-yet-supported functionality) would be thrown later,+  -- when we try to parse the rendered code back inside the GHC monad+  -- wrapper, which would lead to error messages presenting the exceptions+  -- as GHC bugs.+  let printed =+        printSnippetsWithPlacements+          (cfgPrinterOpts cfgWithIndices)+          (Choice.fromBool (cfgDebug cfg))+          result0+      !formattedText = T.concat (fst <$> printed)+  -- Every comment of the input should come out exactly once, and in the+  -- order it went in. The AST check below does not cover this: it compares+  -- the comment streams as multisets, and the comments that travel with+  -- pragmas are not in the stream at all.+  unless (cfgUnsafe cfg) . liftIO $ do+    let violations =+          concat+            [ checkCommentInvariants+                (getLoc <$> inputComments r)+                (reorderableSpans (prParsedSource r))+                placements+            | (ParsedSnippet r, (_, placements)) <- result0 `zip` printed+            ]+        -- Imports are sorted and merged, so a comment attached to one of+        -- them may legitimately come out in a different order than it went+        -- in.+        reorderableSpans hsmod =+          [ spn+          | L l _ <- hsmodImports hsmod,+            Just spn <- [srcSpanToRealSrcSpan (locA l)]+          ]+    unless (null violations) $+      throwIO (OrmoluCommentInvariantsViolated path violations)   when (not (cfgUnsafe cfg) || cfgCheckIdempotence cfg) $ do-    -- Parse the result of pretty-printing again and make sure that AST-    -- is the same as AST of original snippet module span positions.+    -- Parse the result of pretty-printing again and make sure that its AST+    -- is the same as the AST of the original snippet, modulo span+    -- positions.     (_, result1) <-       parseModule'         cfg@@ -144,7 +176,11 @@     -- Try re-formatting the formatted result to check if we get exactly     -- the same output.     when (cfgCheckIdempotence cfg) . liftIO $-      let reformattedText = printSnippets (cfgDebug cfg) result1 $ cfgPrinterOpts cfgWithIndices+      let reformattedText =+            printSnippets+              (cfgPrinterOpts cfgWithIndices)+              (Choice.fromBool (cfgDebug cfg))+              result1        in case diffText formattedText reformattedText path of             Nothing -> return ()             Just diff -> throwIO (OrmoluNonIdempotentOutput diff)@@ -181,11 +217,11 @@ ormoluStdin cfg =   liftIO T.Utf8.getContents >>= ormolu cfg "<stdin>" --- | Refine a 'Config' by incorporating given 'SourceType', 'CabalInfo', and--- fixity overrides 'FixityMap'. You can use 'detectSourceType' to deduce--- 'SourceType' based on the file extension,--- 'CabalUtils.getCabalInfoForSourceFile' to obtain 'CabalInfo' and--- 'getFixityOverridesForSourceFile' for 'FixityMap'.+-- | Refine a 'Config' by incorporating the given 'SourceType', 'CabalInfo',+-- and fixity overrides 'FixityMap'. You can use 'detectSourceType' to deduce+-- the 'SourceType' from the file extension,+-- 'CabalUtils.getCabalInfoForSourceFile' to obtain the 'CabalInfo', and+-- 'getFixityOverridesForSourceFile' for the 'FixityMap'. -- -- @since 0.5.3.0 refineConfig ::

@@ -0,0 +1,326 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RecordWildCards #-}++-- | Positional comment attachment.+--+-- This module decides who owns a comment from where it sits in the source,+-- once, before anything is printed. The answer therefore does not depend on+-- the order in which the printer visits elements, which is what made+-- reordered imports and reassociated operator trees lose comments before.+--+-- The rule is short enough to state in full. Find the element that encloses+-- the comment most tightly. Within that element, find which gap between its+-- children the comment falls into. Then:+--+--   * a comment that starts on the line where the preceding sibling ends+--     trails that sibling;+--   * otherwise, if a sibling follows, the comment goes before it;+--   * otherwise the comment trails the last sibling;+--   * an element with no children at all owns the comment outright.+module Ormolu.Comments.Anchor+  ( CommentAnchor (..),+    attachComments,+    anchorFor,++    -- * Using the anchors while printing+    AnchorMap,+    mkAnchorMap,+    noComments,+    claimBefore,+    commentsBefore,+    claimTrailing,+    claimRemaining,+    pendingComments,+    commentsAnchoredWithin,+  )+where++import Data.List (find, sortOn)+import Data.Map.Strict (Map)+import Data.Map.Strict qualified as Map+import Data.Maybe (listToMaybe)+import Data.Set qualified as Set+import GHC.Types.SrcLoc+import Ormolu.Comments.Tree+import Ormolu.Parser.CommentStream++-- | Where a comment belongs.+data CommentAnchor+  = -- | On its own line(s) above the element+    AnchorBefore RealSrcSpan+  | -- | After the element, either on the same line or below it+    AnchorTrailing RealSrcSpan+  | -- | Inside the element, which has no children of its own+    AnchorInside RealSrcSpan+  | -- | Not inside anything: the comment belongs to the module+    AnchorModule+  deriving (Eq, Show)++-- | Attach every comment of a module.+attachComments ::+  -- | Comments, in source order+  [LComment] ->+  -- | Spans of all \"located\" elements of the module+  [RealSrcSpan] ->+  [(LComment, CommentAnchor)]+attachComments comments eltSpans =+  joinBlocks eltSpans [(c, anchorFor forest c) | c <- comments]+  where+    forest = mkSpanForest eltSpans++-- | Make a run of comment lines share one anchor.+--+-- Consecutive lines with nothing but comment between them are one block as+-- far as the reader is concerned, so splitting them across two elements+-- would tear the block apart. The first line decides where the whole block+-- goes.+joinBlocks ::+  -- | Spans of all elements, used to tell whether one stands between two+  -- comments+  [RealSrcSpan] ->+  [(LComment, CommentAnchor)] ->+  [(LComment, CommentAnchor)]+joinBlocks eltSpans = go Nothing+  where+    -- Only the start positions matter below, and only whether one of them+    -- falls in a range, so they are held as a set: this runs for every+    -- comment and scanning the module's spans each time is quadratic.+    eltStarts = Set.fromList (realSrcSpanStart <$> eltSpans)++    go _ [] = []+    go previous ((c@(L spn theComment), anchor) : rest) =+      let anchor' = case previous of+            Just (prevSpn, prevAnchor)+              | continues prevSpn -> prevAnchor+            _ -> anchor+          continues prevSpn =+            not (hasAtomsBefore theComment)+              && srcSpanEndLine prevSpn + 1 == srcSpanStartLine spn+              && not (elementBetween prevSpn spn)+       in (c, anchor') : go (Just (spn, anchor')) rest++    -- Consecutive lines are not one block if an element begins between+    -- them. @{- 0x00 -} sniExt@ followed by @{- 0x0a -} groupExt@ is two+    -- blocks, each leading its own element, not one block of two lines. It+    -- is enough for the element to *start* in the gap: in @f $ {-else-} do@+    -- the @do@ block opens on the first comment's line and runs well past+    -- the second, and the comment on the next line belongs inside it rather+    -- than to the block above.+    elementBetween from to =+      case Set.lookupGE (realSrcSpanEnd from) eltStarts of+        Just s -> s <= realSrcSpanStart to+        Nothing -> False++-- | Attach a single comment to the forest of element spans.+anchorFor :: [SpanTree] -> LComment -> CommentAnchor+anchorFor forest (L comment theComment) = go Nothing Nothing forest+  where+    go enclosing outerTrailing trees =+      case find (\t -> stSpan t `containsSpan` comment) trees of+        -- Descend into the element that encloses the comment, so that the+        -- anchor is always as tight as the source allows. Carry down the+        -- code this level has already put on the comment's line: an element+        -- that opens on that line, such as the right-hand side in @f x = --+        -- c@, has nothing of its own before the comment, but the comment+        -- still trails the @x@ one level up.+        --+        -- Only an element that wraps a single thing may carry it. One with+        -- several children is a list of items, and a comment written at the+        -- head of such a list introduces the items rather than trailing+        -- what stands before the bracket. In+        --+        -- > xs ++ [ -- why?+        -- >   a, b ]+        --+        -- the comment must stay inside the brackets; carrying it up would+        -- pull it, and the block of comment lines below it, out of the list.+        Just t+          | [_] <- stChildren t -> go (Just (stSpan t)) trailingHere (stChildren t)+          | otherwise -> go (Just (stSpan t)) Nothing (stChildren t)+        Nothing -> case (precedingSibling, followingSibling) of+          (Just p, _)+            | trailsCodeOn (stSpan p) -> AnchorTrailing (innermostEndingOnLine p)+          -- A comment with an element right after it on the same line and+          -- nothing of its own before it leads that element: a run of @{-+          -- 0x00 -} sniExt@ must not be read as trailing whatever comes+          -- before and pile up in one place. This outranks the code carried+          -- down from an outer level, so that the @{-a-}@ of @x = ({-a-} b,+          -- c)@ stays with @b@ rather than being pulled out to trail the+          -- @x@.+          (_, Just n)+            | startsOnCommentLine (stSpan n) -> AnchorBefore (stSpan n)+          -- Nothing at this level stands before the comment, but an outer+          -- level put code on its line: the comment trails that code. This+          -- is what keeps @f x = -- c@ on one line, the right-hand side+          -- having opened on that line with the comment as its first+          -- content.+          --+          -- Only a line comment may do this. It runs to the end of the line+          -- either way, so trailing an element one level up still renders+          -- it exactly where it was written. A block comment renders in+          -- place instead, and would end up ahead of the tokens that opened+          -- the element it was written inside: the pragma of @corebar = {-#+          -- CORE "bar baz" #-}@ would move before the @=@.+          (Nothing, _)+            | not (isMultilineComment theComment),+              Just p <- outerTrailing ->+                AnchorTrailing (innermostEndingOnLine p)+          (_, Just n) -> AnchorBefore (stSpan n)+          -- A comment after the last child of an element belongs to that+          -- element, but a comment after everything at the top level+          -- belongs to the module: there is nothing it can trail without+          -- being rendered before syntax that preceded it in the input,+          -- such as the @where@ of a module header.+          (Just p, Nothing)+            | Just _ <- enclosing -> AnchorTrailing (stSpan p)+            | otherwise -> AnchorModule+          (Nothing, Nothing) -> maybe AnchorModule AnchorInside enclosing+          where+            followingSibling =+              listToMaybe+                [ t+                | t <- trees,+                  realSrcSpanStart (stSpan t) >= realSrcSpanEnd comment+                ]+            startsOnCommentLine s =+              srcSpanStartLine s == srcSpanEndLine comment+      where+        precedingSibling =+          lastMaybe+            [ t+            | t <- trees,+              realSrcSpanEnd (stSpan t) <= realSrcSpanStart comment+            ]+        trailingHere = case precedingSibling of+          Just p | trailsCodeOn (stSpan p) -> Just p+          _ -> outerTrailing++    -- A comment only trails an element when it really does sit after code+    -- on that line. Checking the line alone is not enough, because the AST+    -- has zero-width spans that happen to share a line with a comment while+    -- standing before it.+    trailsCodeOn s =+      srcSpanEndLine s == srcSpanStartLine comment+        && hasAtomsBefore theComment++    -- A comment that trails a bracketed construct belongs to the innermost+    -- element that ends on its line, not to the bracket: @(x + y) -- c@+    -- attaches to @y@, so that the comment is rendered next to the+    -- expression it was written next to rather than after the closing+    -- bracket.+    innermostEndingOnLine t =+      case lastMaybe (filter (trailsCodeOn . stSpan) (stChildren t)) of+        Nothing -> stSpan t+        Just t' -> innermostEndingOnLine t'++    lastMaybe xs = if null xs then Nothing else Just (last xs)++----------------------------------------------------------------------------+-- Using the anchors while printing++-- | Anchored comments, arranged so that the printer can look them up by the+-- span of the element it is entering or leaving.+--+-- Comments are claimed rather than consumed: the first element with a given+-- span takes them, and every later element with the same span finds+-- nothing. Since several AST nodes routinely share a span, and the printer+-- enters them outermost first, this gives the comment to the outermost of+-- them, which is what one wants—a comment belongs outside the parentheses,+-- not inside them.+data AnchorMap = AnchorMap+  { amBefore :: Map RealSrcSpan [LComment],+    amTrailing :: Map RealSrcSpan [LComment],+    amModule :: [LComment]+  }++-- | An empty map, for the first of the two rendering passes: it collects+-- the spans of the elements the printer enters, and emits no comments.+noComments :: AnchorMap+noComments =+  AnchorMap {amBefore = Map.empty, amTrailing = Map.empty, amModule = []}++-- | Arrange anchored comments for lookup.+--+-- __NOTE__: 'AnchorInside' is currently folded into 'AnchorTrailing'. Doing+-- it properly needs a combinator for elements that can have no children at+-- all.+mkAnchorMap :: [(LComment, CommentAnchor)] -> AnchorMap+mkAnchorMap anchored =+  AnchorMap+    { amBefore = collect [(spn, c) | (c, AnchorBefore spn) <- anchored],+      amTrailing =+        collect $+          [(spn, c) | (c, AnchorTrailing spn) <- anchored]+            <> [(spn, c) | (c, AnchorInside spn) <- anchored],+      amModule = [c | (c, AnchorModule) <- anchored]+    }+  where+    collect = Map.fromListWith (flip (<>)) . fmap (fmap pure)++-- | The comments that go before the element with the given span, without+-- claiming them.+commentsBefore :: RealSrcSpan -> AnchorMap -> [LComment]+commentsBefore spn = Map.findWithDefault [] spn . amBefore++-- | Claim the comments that go before the element with the given span.+claimBefore :: RealSrcSpan -> AnchorMap -> ([LComment], AnchorMap)+claimBefore spn am =+  case Map.lookup spn (amBefore am) of+    Nothing -> ([], am)+    Just cs -> (cs, am {amBefore = Map.delete spn (amBefore am)})++-- | Claim the comments that go after the element with the given span.+claimTrailing :: RealSrcSpan -> AnchorMap -> ([LComment], AnchorMap)+claimTrailing spn am =+  case Map.lookup spn (amTrailing am) of+    Nothing -> ([], am)+    Just cs -> (cs, am {amTrailing = Map.delete spn (amTrailing am)})++-- | Claim everything that is left: the comments that belong to no element,+-- plus anything that was anchored to an element the printer never entered.+claimRemaining :: AnchorMap -> ([LComment], AnchorMap)+claimRemaining am =+  ( pendingComments am,+    AnchorMap {amBefore = Map.empty, amTrailing = Map.empty, amModule = []}+  )++-- | The comments anchored to the element at the given span, or to any+-- element inside it.+--+-- This is the question the layout decision needs to ask. "Which comments+-- are contained in this element" is a different and much coarser one: a+-- comment anywhere in a declaration is contained in it, but is attached to+-- one particular element, and only that element's layout should have to+-- account for it. This runs for every element the printer enters, so it+-- must not walk the whole map. Anchors are 'RealSrcSpan's ordered by start+-- position, and all of a module's spans share a file, so the anchors that+-- could be contained in the region are the contiguous run whose start lies+-- within it. Cutting the map down to that run first makes the cost+-- proportional to the size of the region rather than to the number of+-- comments in the module.+commentsAnchoredWithin :: RealSrcSpan -> AnchorMap -> [LComment]+commentsAnchoredWithin region AnchorMap {..} =+  sortOn getLoc . concat $+    within amBefore <> within amTrailing+  where+    within =+      Map.elems+        . Map.filterWithKey (\anchor _ -> region `containsSpan` anchor)+        . startingWithin++    -- Antitone in map order: as keys ascend their start position never+    -- decreases, so each predicate holds on a prefix and then stops.+    startingWithin =+      fst+        . Map.spanAntitone ((<= realSrcSpanEnd region) . realSrcSpanStart)+        . snd+        . Map.spanAntitone ((< realSrcSpanStart region) . realSrcSpanStart)++-- | Every comment that has not been emitted yet, in source order.+pendingComments :: AnchorMap -> [LComment]+pendingComments AnchorMap {..} =+  sortOn getLoc $+    amModule+      <> concat (Map.elems amBefore)+      <> concat (Map.elems amTrailing)

@@ -0,0 +1,135 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}++-- | Properties that comment handling has to satisfy, and the check that+-- enforces them.+--+-- Every comment of the input should come out exactly once, and in the order+-- it went in. The check runs on every run of Ormolu, alongside the check+-- that the AST is unchanged, and is disabled by the same @--unsafe@ flag.+--+-- This is the half of comment checking that works on where the comments went+-- rather than on what they say. It compares the /spans/ of the comments a+-- module started with against the spans recorded as the printer emitted+-- them, so it can name the comment that was dropped, duplicated, invented+-- or moved.+--+-- It does /not/ look at the text of a comment at all: rendering one with+-- its contents mangled would pass. That is the other half, and it belongs+-- to 'Ormolu.Diff.ParseResult.diffCommentStream', which compares text and+-- ignores position. Neither check subsumes the other and both run by+-- default.+--+-- Haddocks are outside both halves. GHC's parser makes them part of the AST+-- rather than leaving them in the comment stream, so they are neither among+-- the comments a module started with nor in what the text check compares.+-- Losing or duplicating one changes the AST itself, and that is caught by+-- the third check, 'Ormolu.Diff.ParseResult.diffParseResult' comparing the+-- two syntax trees.+module Ormolu.Comments.Invariants+  ( InvariantViolation (..),+    checkCommentInvariants,+    renderInvariantViolation,+  )+where++import Data.List (sort)+import Data.Map.Strict qualified as Map+import Data.Text (Text)+import Data.Text qualified as T+import GHC.Types.SrcLoc+import Ormolu.Printer.CommentPlacement++-- | A way in which the emitted comments failed to correspond to the+-- comments of the input.+data InvariantViolation+  = -- | A comment of the input was never emitted+    CommentDropped RealSrcSpan+  | -- | A comment was emitted more than once, the given number of times+    CommentDuplicated RealSrcSpan Int+  | -- | A comment was emitted that does not correspond to any comment of+    -- the input+    CommentInvented RealSrcSpan+  | -- | A comment was emitted after one that comes later in the input. The+    -- first span is the comment that was emitted too late, the second is+    -- the one it should have preceded.+    CommentReordered RealSrcSpan RealSrcSpan+  deriving (Eq, Show)++-- | Compare the comments of a snippet against the comments that were+-- emitted while rendering it.+checkCommentInvariants ::+  -- | Spans of all the comments the snippet started with+  [RealSrcSpan] ->+  -- | Spans of the elements the formatter is allowed to reorder, so that+  -- the comments travelling with them are exempt from the order check+  [RealSrcSpan] ->+  -- | Placements recorded while rendering it, in the order of emission+  [CommentPlacement] ->+  [InvariantViolation]+checkCommentInvariants inputSpans reorderable placements =+  dropped <> duplicated <> invented <> reordered+  where+    emitted = cpSpan <$> placements+    -- Pragmas and imports are deliberately sorted and the comments attached+    -- to them travel along, so the order they come out in says nothing.+    -- They are still expected to come out exactly once, which is what+    -- catches a comment being duplicated.+    ordered =+      [ spn+      | CommentPlacement {cpSpan = spn, cpSlot} <- placements,+        cpSlot /= SlotPragma,+        not (travelsWithAReorderedElement cpSlot)+      ]+    travelsWithAReorderedElement slot = case slotAnchor slot of+      Nothing -> False+      Just anchor -> any (`containsSpan` anchor) reorderable+    inputSet = Map.fromList ((,()) <$> inputSpans)+    counts = Map.fromListWith (+) ((,1 :: Int) <$> emitted)++    dropped =+      [CommentDropped spn | spn <- sort inputSpans, not (spn `Map.member` counts)]+    duplicated =+      [ CommentDuplicated spn n+      | (spn, n) <- Map.toAscList counts,+        n > 1+      ]+    invented =+      [ CommentInvented spn+      | spn <- Map.keys counts,+        not (spn `Map.member` inputSet)+      ]++    -- Only the first emission of each comment is considered, so that a+    -- comment reported as duplicated is not also reported as reordered.+    reordered = go [] (dedupe [] ordered)+      where+        dedupe _ [] = []+        dedupe seen (x : xs)+          | x `elem` seen = dedupe seen xs+          | otherwise = x : dedupe (x : seen) xs+        go _ [] = []+        go seen (x : xs) =+          [CommentReordered x y | y <- seen, x < y]+            <> go (x : seen) xs++-- | Render a violation as a single line.+renderInvariantViolation :: InvariantViolation -> Text+renderInvariantViolation = \case+  CommentDropped spn ->+    "dropped     " <> renderSpan spn+  CommentDuplicated spn n ->+    "duplicated  " <> renderSpan spn <> " (emitted " <> showT n <> " times)"+  CommentInvented spn ->+    "invented    " <> renderSpan spn+  CommentReordered spn before ->+    "reordered   " <> renderSpan spn <> " (emitted after " <> renderSpan before <> ")"++renderSpan :: RealSrcSpan -> Text+renderSpan spn =+  renderLoc (realSrcSpanStart spn) <> "-" <> renderLoc (realSrcSpanEnd spn)+  where+    renderLoc l = showT (srcLocLine l) <> ":" <> showT (srcLocCol l)++showT :: (Show a) => a -> Text+showT = T.pack . show

@@ -0,0 +1,74 @@+-- | The containment tree of AST element spans.+--+-- This is the structure "Ormolu.Comments.Anchor" reads to place a comment:+-- given a comment, which element encloses it most tightly, and which of+-- that element's children does it fall between. Arranging the spans by+-- containment is what makes those questions answerable from position alone,+-- without reference to the order in which the printer visits anything.+module Ormolu.Comments.Tree+  ( SpanTree (..),+    mkSpanForest,+    countNodes,+  )+where++import Data.List (sortOn)+import Data.Ord (Down (..))+import GHC.Types.SrcLoc++-- | An element span together with the element spans it encloses. Children+-- are in ascending order and do not overlap each other.+data SpanTree = SpanTree+  { stSpan :: RealSrcSpan,+    stChildren :: [SpanTree]+  }+  deriving (Eq, Show)++-- | Arrange spans into a forest by containment.+--+-- Duplicates are dropped: several AST nodes routinely share one span (a+-- wrapper and the thing it wraps, say), and for the purpose of owning a+-- comment they are one element. Spans that overlap another without being+-- contained in it are dropped too—the GHC AST does produce such spans+-- occasionally, and they cannot be placed in a tree.+--+-- Zero-width spans are kept. An empty bracketed construct—an export or+-- import list, @[]@, a record with no fields—contains no element at all, so+-- the printer enters a zero-width one at its opening bracket+-- ('Ormolu.Printer.Combinators.locatedEmpty') to give a comment written+-- between the brackets something to attach to.+mkSpanForest :: [RealSrcSpan] -> [SpanTree]+mkSpanForest = goForest . dedupe . sortOn nestingOrder+  where+    -- Outermost first, so that a span is always seen before the spans it+    -- contains.+    nestingOrder s = (realSrcSpanStart s, Down (realSrcSpanEnd s))++    dedupe (x : y : rest) | x == y = dedupe (y : rest)+    dedupe (x : rest) = x : dedupe rest+    dedupe [] = []++    goForest [] = []+    goForest (s : rest) =+      let (children, rest') = goChildren s rest+       in SpanTree s children : goForest rest'++    goChildren parent = go []+      where+        go acc [] = (reverse acc, [])+        go acc (s : rest)+          | parent `containsSpan` s =+              let (children, rest') = goChildren s rest+               in go (SpanTree s children : acc) rest'+          | realSrcSpanStart s < realSrcSpanEnd parent =+              -- Overlaps the parent without being contained in it; there is+              -- no correct place for it, so leave it out.+              go acc rest+          | otherwise = (reverse acc, s : rest)++-- | How many elements the forest holds. Used by the tests to check that+-- duplicate and overlapping spans are dropped.+countNodes :: [SpanTree] -> Int+countNodes = sum . fmap node+  where+    node t = 1 + countNodes (stChildren t)

@@ -35,6 +35,7 @@     fillMissingPrinterOpts,     resolvePrinterOpts,     CommaStyle (..),+    RecordStyle (..),     FunctionArrowsStyle (..),     HaddockPrintStyle (..),     HaddockPrintStyleModule (..),@@ -43,12 +44,13 @@     ImportGrouping (..),     ImportGroup (..),     ImportGroupRule (..),-    ImportModuleMatcher (..),     ImportRulePriority (..),     matchAllRulePriority,     matchLocalRulePriority,     defaultImportRulePriority,+    ImportListMatcher (..),     QualifiedImportMatcher (..),+    ImportScopeMatcher (..),     LetStyle (..),     InStyle (..),     IfStyle (..),@@ -111,7 +113,8 @@     cfgDynOptions :: ![DynOption],     -- | Fixity overrides     cfgFixityOverrides :: !FixityOverrides,-    -- | Module reexports to take into account when doing fixity resolution+    -- | Module re-exports to take into account when performing fixity+    -- resolution     cfgModuleReexports :: !ModuleReexports,     -- | Known dependencies, if any     cfgDependencies :: !(Set PackageName),@@ -119,9 +122,9 @@     cfgUnsafe :: !Bool,     -- | Output information useful for debugging     cfgDebug :: !Bool,-    -- | Checks if re-formatting the result is idempotent+    -- | Check that re-formatting the result is idempotent     cfgCheckIdempotence :: !Bool,-    -- | How to parse the input (regular haskell module or Backpack file)+    -- | How to parse the input (a regular Haskell module or a Backpack file)     cfgSourceType :: !SourceType,     -- | Whether to use colors and other features of ANSI terminals     cfgColorMode :: !ColorMode,

@@ -1,5 +1,5 @@ {- FOURMOLU_DISABLE -}-{- ***** DO NOT EDIT: This module is autogenerated ***** -}+{- DO NOT EDIT: This module is autogenerated -}  {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE LambdaCase #-}@@ -9,6 +9,7 @@ module Ormolu.Config.Gen   ( PrinterOpts (..)   , CommaStyle (..)+  , RecordStyle (..)   , FunctionArrowsStyle (..)   , HaddockPrintStyle (..)   , HaddockPrintStyleModule (..)@@ -54,6 +55,8 @@       poFunctionArrows :: f FunctionArrowsStyle     , -- | How to place commas in multi-line lists, records, etc.       poCommaStyle :: f CommaStyle+    , -- | How to place braces in records+      poRecordStyle :: f RecordStyle     , -- | Styling of import/export lists       poImportExportStyle :: f ImportExportStyle     , -- | Rules for grouping import declarations@@ -102,6 +105,7 @@     , poColumnLimit = Nothing     , poFunctionArrows = Nothing     , poCommaStyle = Nothing+    , poRecordStyle = Nothing     , poImportExportStyle = Nothing     , poImportGrouping = Nothing     , poIndentWheres = Nothing@@ -130,6 +134,7 @@     , poColumnLimit = pure NoLimit     , poFunctionArrows = pure TrailingArrows     , poCommaStyle = pure Leading+    , poRecordStyle = pure RecordStyleAligned     , poImportExportStyle = pure ImportExportDiffFriendly     , poImportGrouping = pure ImportGroupLegacy     , poIndentWheres = pure False@@ -165,6 +170,7 @@     , poColumnLimit = maybe (poColumnLimit p2) pure (poColumnLimit p1)     , poFunctionArrows = maybe (poFunctionArrows p2) pure (poFunctionArrows p1)     , poCommaStyle = maybe (poCommaStyle p2) pure (poCommaStyle p1)+    , poRecordStyle = maybe (poRecordStyle p2) pure (poRecordStyle p1)     , poImportExportStyle = maybe (poImportExportStyle p2) pure (poImportExportStyle p1)     , poImportGrouping = maybe (poImportGrouping p2) pure (poImportGrouping p1)     , poIndentWheres = maybe (poIndentWheres p2) pure (poIndentWheres p1)@@ -209,6 +215,10 @@       "How to place commas in multi-line lists, records, etc. (choices: \"leading\" or \"trailing\") (default: leading)"       "OPTION"     <*> f+      "record-style"+      "How to place braces in records (choices: \"aligned\" or \"knr\") (default: aligned)"+      "OPTION"+    <*> f       "import-export-style"       "Styling of import/export lists (choices: \"leading\", \"trailing\", or \"diff-friendly\") (default: diff-friendly)"       "OPTION"@@ -230,7 +240,7 @@       "INT"     <*> f       "haddock-style"-      "How to print Haddock comments (choices: \"single-line\", \"multi-line\", or \"multi-line-compact\") (default: multi-line)"+      "How to print Haddock comments (choices: \"single-line\", \"multi-line\", \"multi-line-compact\", or \"auto\") (default: multi-line)"       "OPTION"     <*> f       "haddock-style-module"@@ -295,6 +305,7 @@     <*> f "column-limit"     <*> f "function-arrows"     <*> f "comma-style"+    <*> f "record-style"     <*> f "import-export-style"     <*> f "import-grouping"     <*> f "indent-wheres"@@ -348,6 +359,11 @@   | Trailing   deriving (Eq, Show, Enum, Bounded) +data RecordStyle+  = RecordStyleAligned+  | RecordStyleKnr+  deriving (Eq, Show, Enum, Bounded)+ data FunctionArrowsStyle   = TrailingArrows   | LeadingArrows@@ -358,6 +374,7 @@   = HaddockSingleLine   | HaddockMultiLine   | HaddockMultiLineCompact+  | HaddockAuto   deriving (Eq, Show, Enum, Bounded)  data HaddockPrintStyleModule@@ -450,6 +467,28 @@     Leading -> "leading"     Trailing -> "trailing" +instance Aeson.FromJSON RecordStyle where+  parseJSON =+    Aeson.withText "RecordStyle" $ \s ->+      either Aeson.parseFail pure $+        parsePrinterOptType (Text.unpack s)++instance PrinterOptsFieldType RecordStyle where+  parsePrinterOptType s =+    case s of+      "aligned" -> Right RecordStyleAligned+      "knr" -> Right RecordStyleKnr+      _ ->+        Left . unlines $+          [ "unknown value: " <> show s+          , "Valid values are: \"aligned\" or \"knr\""+          ]++instance RenderPrinterOpt RecordStyle where+  renderPrinterOpt = \case+    RecordStyleAligned -> "aligned"+    RecordStyleKnr -> "knr"+ instance Aeson.FromJSON FunctionArrowsStyle where   parseJSON =     Aeson.withText "FunctionArrowsStyle" $ \s ->@@ -486,10 +525,11 @@       "single-line" -> Right HaddockSingleLine       "multi-line" -> Right HaddockMultiLine       "multi-line-compact" -> Right HaddockMultiLineCompact+      "auto" -> Right HaddockAuto       _ ->         Left . unlines $           [ "unknown value: " <> show s-          , "Valid values are: \"single-line\", \"multi-line\", or \"multi-line-compact\""+          , "Valid values are: \"single-line\", \"multi-line\", \"multi-line-compact\", or \"auto\""           ]  instance RenderPrinterOpt HaddockPrintStyle where@@ -497,6 +537,7 @@     HaddockSingleLine -> "single-line"     HaddockMultiLine -> "multi-line"     HaddockMultiLineCompact -> "multi-line-compact"+    HaddockAuto -> "auto"  instance Aeson.FromJSON HaddockPrintStyleModule where   parseJSON =@@ -777,6 +818,9 @@     , "# How to place commas in multi-line lists, records, etc. (choices: leading or trailing)"     , "comma-style: leading"     , ""+    , "# How to place braces in records (choices: aligned or knr)"+    , "record-style: aligned"+    , ""     , "# Styling of import/export lists (choices: leading, trailing, or diff-friendly)"     , "import-export-style: diff-friendly"     , ""@@ -792,7 +836,7 @@     , "# Number of spaces between top-level declarations"     , "newlines-between-decls: 1"     , ""-    , "# How to print Haddock comments (choices: single-line, multi-line, or multi-line-compact)"+    , "# How to print Haddock comments (choices: single-line, multi-line, multi-line-compact, or auto)"     , "haddock-style: multi-line"     , ""     , "# How to print module docstring"

@@ -1,20 +1,22 @@+{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-}  module Ormolu.Config.Types   ( ImportGroup (..),     ImportGroupRule (..),-    ImportModuleMatcher (..),     ImportRulePriority (..),     matchAllRulePriority,     matchLocalRulePriority,     defaultImportRulePriority,+    ImportListMatcher (..),     QualifiedImportMatcher (..),+    ImportScopeMatcher (..),   ) where -import Control.Applicative (Alternative (..), asum)-import Data.Aeson ((.!=), (.:), (.:?))+import Control.Applicative (Alternative (..))+import Data.Aeson ((.!=), (.:?)) import Data.Aeson qualified as Aeson import Data.Aeson.Types qualified as Aeson import Data.List.NonEmpty (NonEmpty)@@ -34,28 +36,47 @@       <*> Aeson.parseField o "rules"  data ImportGroupRule = ImportGroupRule-  { igrModuleMatcher :: !ImportModuleMatcher,+  { igrGlob :: !Glob,+    igrImportListMatcher :: !ImportListMatcher,     igrQualifiedMatcher :: !QualifiedImportMatcher,+    igrScopeMatcher :: !ImportScopeMatcher,     igrPriority :: !ImportRulePriority   }   deriving (Eq, Show)  instance Aeson.FromJSON ImportGroupRule where   parseJSON = Aeson.withObject "rule" $ \o -> do-    let parseModuleMatcher = Aeson.parseJSON (Aeson.Object o)-        failUnknownModuleMatcher = Aeson.parseFail "Unknown or invalid module matcher"-        attemptParseModuleMatcher = parseModuleMatcher <|> failUnknownModuleMatcher-    igrModuleMatcher <- attemptParseModuleMatcher+    legacyMatch <- o .:? "match"+    (defaultPriority, defaultScope) <- case legacyMatch of+      Just "all" -> pure (matchAllRulePriority, pure MatchAllModules)+      Just "local-modules" -> pure (matchLocalRulePriority, pure MatchLocalModules)+      Just other -> Aeson.parseFail $ "Unknown legacy match value: " <> other+      Nothing -> pure (defaultImportRulePriority, empty) -    qualified <- o .:? "qualified"-    igrQualifiedMatcher <- case qualified of-      Just True -> pure MatchQualifiedOnly-      Just False -> pure MatchUnqualifiedOnly-      Nothing -> pure MatchBothQualifiedAndUnqualified+    igrGlob <- mkGlob <$> o .:? "glob" .!= "**" -    let defaultPriority-          | MatchAllModules <- igrModuleMatcher = matchAllRulePriority-          | otherwise = defaultImportRulePriority+    igrImportListMatcher <-+      o .:? "import-list" .!= "any" >>= \case+        "any" -> pure MatchAnyImportDeclaration+        "explicit" -> pure MatchExplicitImportList+        "hiding" -> pure MatchHidingImportClause+        "none" -> pure MatchWholeModuleImport+        other -> Aeson.parseFail $ "Unknown import list matcher: " <> other++    igrQualifiedMatcher <-+      o .:? "qualified" >>= \case+        Just True -> pure MatchQualifiedOnly+        Just False -> pure MatchUnqualifiedOnly+        Nothing -> pure MatchBothQualifiedAndUnqualified++    igrScopeMatcher <-+      o .:? "scope" >>= \case+        Just "any" -> pure MatchAllModules+        Just "local" -> pure MatchLocalModules+        Just "external" -> pure MatchExternalModules+        Nothing -> defaultScope <|> pure MatchAllModules+        Just other -> Aeson.parseFail ("Unknown scope matcher: " <> other)+     igrPriority <- o .:? "priority" .!= defaultPriority      pure ImportGroupRule {..}@@ -75,35 +96,21 @@ defaultImportRulePriority :: ImportRulePriority defaultImportRulePriority = ImportRulePriority 50 +data ImportListMatcher+  = MatchExplicitImportList+  | MatchHidingImportClause+  | MatchWholeModuleImport+  | MatchAnyImportDeclaration+  deriving (Eq, Show)+ data QualifiedImportMatcher   = MatchQualifiedOnly   | MatchUnqualifiedOnly   | MatchBothQualifiedAndUnqualified   deriving (Eq, Show) -data ImportModuleMatcher-  = MatchAllModules+data ImportScopeMatcher+  = MatchExternalModules   | MatchLocalModules-  | MatchGlob !Glob+  | MatchAllModules   deriving (Eq, Show)--instance Aeson.FromJSON ImportModuleMatcher where-  parseJSON v =-    asum-      [ parseMatchModuleMatcher v,-        parseGlobModuleMatcher v-      ]-    where-      parseMatchModuleMatcher :: Aeson.Value -> Aeson.Parser ImportModuleMatcher-      parseMatchModuleMatcher = Aeson.withObject "ImportModuleMatcher" $ \o -> do-        c <- Aeson.parseField @String o "match"-        case c of-          "all" -> pure MatchAllModules-          "local-modules" -> pure MatchLocalModules-          other -> Aeson.parseFail $ "Unknown matcher: " <> other--      parseGlobModuleMatcher :: Aeson.Value -> Aeson.Parser ImportModuleMatcher-      parseGlobModuleMatcher = Aeson.withObject "ImportModuleMatcher" $ \o -> do-        rawGlob <- o .: "glob"-        let glob = mkGlob rawGlob-        pure (MatchGlob glob)

@@ -2,6 +2,8 @@ {-# LANGUAGE DeepSubsumption #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ViewPatterns #-} @@ -9,15 +11,17 @@ module Ormolu.Diff.ParseResult   ( ParseResultDiff (..),     diffParseResult,+    diffCommentStream,   ) where  import Data.ByteString (ByteString) import Data.Char (isSpace)+import Data.Choice (pattern Without) import Data.Foldable import Data.Function import Data.Generics-import Data.List (sortOn)+import Data.List (sort, sortOn) import Data.Text qualified as T import GHC.Data.FastString (FastString) import GHC.Hs@@ -25,6 +29,7 @@ import GHC.Types.SrcLoc import Ormolu.Config.Gen (ImportGrouping (ImportGroupSingle)) import Ormolu.Imports (normalizeImports)+import Ormolu.Imports.Grouping (GroupImportsOpts (..)) import Ormolu.Parser.CommentStream import Ormolu.Parser.Result import Ormolu.Utils@@ -46,7 +51,12 @@ instance Monoid ParseResultDiff where   mempty = Same --- | Return 'Diff' of two 'ParseResult's.+-- | Compare the parse result of the input against that of the output.+--+-- Two of Ormolu's three comment checks live here: 'diffCommentStream' for+-- the text of the comments, and the syntax tree comparison for the+-- Haddocks, which are part of the tree rather than of the comment stream.+-- The third, "Ormolu.Comments.Invariants", checks where the comments went. diffParseResult ::   ParseResult ->   ParseResult ->@@ -62,15 +72,50 @@     } =     diffCommentStream cstream0 cstream1       <> diffHsModule-        hs0 {hsmodImports = concat . normalizeImports False mempty ImportGroupSingle $ hsmodImports hs0}-        hs1 {hsmodImports = concat . normalizeImports False mempty ImportGroupSingle $ hsmodImports hs1}+        hs0 {hsmodImports = concat $ normalizeImports' hs0}+        hs1 {hsmodImports = concat $ normalizeImports' hs1}+    where+      -- The exact parameters here don't matter, it just needs to be consistent+      normalizeImports' hsmod =+        normalizeImports+          GroupImportsOpts+            { grouping = ImportGroupSingle,+              respectful = False,+              allComments = listify (const True) hsmod+            }+          mempty+          (Without #implicitPrelude)+          (hsmodImports hsmod) +-- | Check that formatting did not change the /text/ of any comment.+--+-- This is the half of comment checking that works on what the comments say+-- rather than on where they went. Ormolu edits comment text on purpose—it+-- escapes Haddock triggers, re-indents block comments and normalizes the+-- spacing after a trigger—and both sides of this comparison have been+-- through 'Ormolu.Parser.CommentStream.mkCommentStream', so the intended+-- edits cancel out and only unintended ones show up.+--+-- What it deliberately does /not/ check:+--+--   * __order__, because Ormolu sorts imports, import lists and pragmas,+--     and a comment attached to one of those travels with it;+--   * __which comment is which__, since the lines are compared as a+--     multiset; a failure cannot say more than that the two sides differ,+--     which is why 'Different' is returned with no spans;+--   * __comments outside the stream__ — the Stack header and the comments+--     that travel with pragmas are lifted out of it during parsing, so+--     duplicating one of those is invisible here.+--+-- All three are covered by "Ormolu.Comments.Invariants", which compares+-- spans instead of text. Neither check subsumes the other and both run by+-- default. diffCommentStream :: CommentStream -> CommentStream -> ParseResultDiff diffCommentStream (CommentStream cs) (CommentStream cs')   | commentLines cs == commentLines cs' = Same   | otherwise = Different []   where-    commentLines = concatMap (toList . unComment . unLoc)+    commentLines = sort . concatMap (toList . unComment . unLoc)  -- | Compare two modules for equality disregarding certain semantically -- irrelevant features like exact print annotations.@@ -106,11 +151,13 @@                   `extQ` considerEqual @EpLayout                   `extQ` considerEqual @AnnSig                   `extQ` considerEqual @HsRuleAnn-                  `extQ` considerEqual @EpLinearArrow+                  `extQ` considerEqual @EpLinear                   `extQ` considerEqual @AnnSynDecl                   `extQ` considerEqual @IsUnicodeSyntax                   -- FastString (for example for string literals)                   `extQ` considerEqualVia' ((==) @FastString)+                  -- ModuleName is a newtype of FastString+                  `extQ` considerEqualVia' ((==) @ModuleName)                   -- Haddock strings                   `extQ` hsDocStringEq                   -- Whether imports are pre- or post-qualified@@ -170,14 +217,37 @@     epAnnEq :: EpAnn a -> b -> ParseResultDiff     epAnnEq _ _ = Same +    importDeclQualifiedStyleEq :: forall a. (Data a) => ImportDeclQualifiedStyle -> a -> ParseResultDiff     importDeclQualifiedStyleEq = considerEqualVia' f       where         f QualifiedPre QualifiedPost = True         f QualifiedPost QualifiedPre = True         f x x' = x == x' +    -- Documentation is compared up to the normalizations Ormolu performs+    -- on it: the space it puts after a Haddock's trigger, the+    -- re-indentation it gives a @{- | … -}@ so that the comment lines up+    -- with the code it documents, and the collapsing of consecutive blank+    -- lines. All three change the doc string GHC parses back out, and all+    -- three are intended.     hsDocStringEq :: HsDocString -> GenericQ ParseResultDiff-    hsDocStringEq = considerEqualVia' ((==) `on` (map (T.dropWhile isSpace) . splitDocString True))+    hsDocStringEq =+      considerEqualVia' ((==) `on` (collapseBlanks . dedent . splitDocString))+      where+        -- The printer emits at most one blank line in a row, as it does for+        -- ordinary comments.+        collapseBlanks = \case+          (x : y : rest)+            | T.null x, T.null y -> collapseBlanks (y : rest)+          (x : rest) -> x : collapseBlanks rest+          [] -> []+        dedent = \case+          [] -> []+          (x : xs) ->+            let indentOf l = T.length (T.takeWhile (== ' ') l)+                indents = indentOf <$> filter (not . T.all isSpace) xs+                n = if null indents then 0 else minimum indents+             in x : fmap (T.drop n) xs      forLocated ::       (Data e0, Data e1) =>

@@ -1,4 +1,3 @@-{-# LANGUAGE CPP #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE QualifiedDo #-}@@ -24,9 +23,6 @@ import GHC.Types.SrcLoc import Ormolu.Terminal import Ormolu.Terminal.QualifiedDo qualified as Term-#if !MIN_VERSION_base(4,20,0)-import Data.List (foldl')-#endif  ---------------------------------------------------------------------------- -- Types@@ -260,7 +256,7 @@       hunkDiff = mapDiff (fmap third) xs   return Hunk {..} --- | Trim empty “both” lines from beginning and end of a 'DiffList''.+-- | Trim empty “both” lines from the beginning and end of a 'DiffList''. trimEmpty :: DiffList' -> DiffList' trimEmpty = go True id   where

@@ -19,6 +19,7 @@ import Data.Void (Void) import Distribution.Parsec.Error (PError, showPError) import GHC.Types.SrcLoc+import Ormolu.Comments.Invariants (InvariantViolation, renderInvariantViolation) import Ormolu.Diff.Text (TextDiff, printTextDiff) import Ormolu.Terminal import Ormolu.Terminal.QualifiedDo qualified as Term@@ -36,6 +37,9 @@     OrmoluASTDiffers TextDiff [RealSrcSpan]   | -- | Formatted source code is not idempotent     OrmoluNonIdempotentOutput TextDiff+  | -- | The comments that came out do not correspond to the comments that+    -- went in+    OrmoluCommentInvariantsViolated FilePath [InvariantViolation]   | -- | Some GHC options were not recognized     OrmoluUnrecognizedOpts (NonEmpty String)   | -- | Cabal file parsing failed@@ -91,6 +95,22 @@     newline     put "  Please, consider reporting the bug."     newline+  OrmoluCommentInvariantsViolated path violations -> Term.do+    put (T.pack path)+    newline+    for_ violations $ \violation -> Term.do+      put "  "+      put (renderInvariantViolation violation)+      newline+    newline+    put "  The comments of the output do not correspond to the comments of"+    newline+    put "  the input."+    newline+    put "  Please, consider reporting the bug."+    newline+    put "  To format anyway, use --unsafe."+    newline   OrmoluUnrecognizedOpts opts -> Term.do     put "The following GHC options were not recognized:"     newline@@ -106,13 +126,13 @@   OrmoluMissingStdinInputFile -> Term.do     put "The --stdin-input-file option is necessary when using input"     newline-    put "from stdin and accounting for .cabal files"+    put "from stdin and accounting for .cabal files."     newline   OrmoluFixityOverridesParseError errorBundle -> Term.do     put . T.pack . errorBundlePretty $ errorBundle     newline --- | Inside this wrapper 'OrmoluException' will be caught and displayed+-- | Inside this wrapper, 'OrmoluException' will be caught and displayed -- nicely. withPrettyOrmoluExceptions ::   -- | Color mode@@ -126,12 +146,13 @@       runTerm (printOrmoluException e) colorMode stderr       return . ExitFailure $         case e of-          -- Error code 1 is for 'error' or 'notImplemented'-          -- 2 used to be for erroring out on CPP+          -- Error code 1 is for 'error' or 'notImplemented'.+          -- 2 used to be for erroring out on CPP.           OrmoluParsingFailed {} -> 3           OrmoluOutputParsingFailed {} -> 4           OrmoluASTDiffers {} -> 5           OrmoluNonIdempotentOutput {} -> 6+          OrmoluCommentInvariantsViolated {} -> 11           OrmoluUnrecognizedOpts {} -> 7           OrmoluCabalFileParsingFailed {} -> 8           OrmoluMissingStdinInputFile {} -> 9

@@ -53,7 +53,7 @@   Binary.runGet Binary.get $     BL.fromStrict $(embedFile "extract-hackage-info/hackage-info.bin") --- | Default set of packages to assume as dependencies e.g. when no Cabal+-- | Default set of packages to assume as dependencies, e.g. when no Cabal -- file is found or taken into consideration. defaultDependencies :: Set PackageName defaultDependencies = Set.singleton (mkPackageName "base")

@@ -75,7 +75,7 @@   IEThingWith _ (L _ x) _ xs _ -> occName x : fmap (occName . unLoc) xs   _ -> [] --- | Apply given module re-exports.+-- | Apply the given module re-exports. applyModuleReexports :: ModuleReexports -> [FixityImport] -> [FixityImport] applyModuleReexports (ModuleReexports reexports) imports = imports >>= expand   where

@@ -74,7 +74,7 @@  {-# COMPLETE OpName #-} --- | Convert an 'OccName to an 'OpName'.+-- | Convert an 'OccName' to an 'OpName'. occOpName :: OccName -> OpName occOpName = MkOpName . fs_sbs . occNameFS @@ -125,10 +125,10 @@ data FixityApproximation = FixityApproximation   { -- | Fixity direction if it is known     faDirection :: Maybe FixityDirection,-    -- | Minimum precedence level found in the (maybe conflicting)+    -- | Minimum precedence level found in the (possibly conflicting)     -- definitions for the operator (inclusive)     faMinPrecedence :: Double,-    -- | Maximum precedence level found in the (maybe conflicting)+    -- | Maximum precedence level found in the (possibly conflicting)     -- definitions for the operator (inclusive)     faMaxPrecedence :: Double   }@@ -146,8 +146,8 @@     faMaxPrecedence <- Binary.getDoublele     pure FixityApproximation {..} --- | Gives the ability to merge two (maybe conflicting) definitions for an--- operator, keeping the higher level of compatible information from both.+-- | Gives the ability to merge two (possibly conflicting) definitions for+-- an operator, keeping the higher level of compatible information from both. instance Semigroup FixityApproximation where   FixityApproximation {faDirection = dir1, faMinPrecedence = min1, faMaxPrecedence = max1}     <> FixityApproximation {faDirection = dir2, faMinPrecedence = min2, faMaxPrecedence = max2} =@@ -190,7 +190,7 @@ defaultFixityOverrides :: FixityOverrides defaultFixityOverrides = FixityOverrides Map.empty --- | Module re-exports+-- | Module re-exports. newtype ModuleReexports = ModuleReexports   { unModuleReexports :: Map ModuleName (NonEmpty (Maybe PackageName, ModuleName))   }@@ -198,61 +198,7 @@  -- | Module re-exports to apply by default. defaultModuleReexports :: ModuleReexports-defaultModuleReexports =-  ModuleReexports . Map.fromList $-    [ ( "Control.Lens",-        l-          "lens"-          [ "Control.Lens.At",-            "Control.Lens.Cons",-            "Control.Lens.Each",-            "Control.Lens.Empty",-            "Control.Lens.Equality",-            "Control.Lens.Fold",-            "Control.Lens.Getter",-            "Control.Lens.Indexed",-            "Control.Lens.Iso",-            "Control.Lens.Lens",-            "Control.Lens.Level",-            "Control.Lens.Plated",-            "Control.Lens.Prism",-            "Control.Lens.Reified",-            "Control.Lens.Review",-            "Control.Lens.Setter",-            "Control.Lens.TH",-            "Control.Lens.Traversal",-            "Control.Lens.Tuple",-            "Control.Lens.Type",-            "Control.Lens.Wrapped",-            "Control.Lens.Zoom"-          ]-      ),-      ( "Servant",-        l-          "servant"-          [ "Servant.API"-          ]-      ),-      ( "Optics",-        l-          "optics"-          [ "Optics.Fold",-            "Optics.Operators",-            "Optics.IxAffineFold",-            "Optics.IxFold",-            "Optics.IxTraversal",-            "Optics.Traversal"-          ]-      ),-      ( "Test.Hspec",-        l-          "hspec-expectations"-          [ "Test.Hspec.Expectations"-          ]-      )-    ]-  where-    l packageName xs = (Just packageName,) <$> NE.fromList xs+defaultModuleReexports = ModuleReexports Map.empty  -- | Fixity information that is specific to a package being formatted. It -- requires module-specific imports in order to be usable.

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE DataKinds #-} {-# LANGUAGE DerivingStrategies #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE RecordWildCards #-}@@ -13,6 +13,8 @@  import Data.Bifunctor import Data.Char (isAlphaNum)+import Data.Choice (Choice)+import Data.Choice qualified as Choice import Data.Function (on) import Data.List (nubBy, sortBy, sortOn) import Data.Map.Strict (Map)@@ -27,31 +29,46 @@ import GHC.Types.PkgQual import GHC.Types.SourceText import GHC.Types.SrcLoc-import Ormolu.Config (ImportGrouping)-import Ormolu.Imports.Grouping (Import (..), groupImports, prepareExistingGroups)+import Ormolu.Imports.Grouping+  ( GroupImportsOpts,+    Import (..),+    ImportList (..),+    groupImports,+    prepareExistingGroups,+  ) import Ormolu.Utils (notImplemented, showOutputable)-#if !MIN_VERSION_base(4,20,0)-import Data.List (foldl')-#endif  -- | Sort, group and normalize imports. -- -- Assumes input list is sorted by source location. Output list is not necessarily -- sorted by source location, so this function should be called at most once on a -- given input list.-normalizeImports :: Bool -> Set Cabal.ModuleName -> ImportGrouping -> [LImportDecl GhcPs] -> [[LImportDecl GhcPs]]-normalizeImports respectful localModules importGrouping =+normalizeImports ::+  GroupImportsOpts ->+  Set Cabal.ModuleName ->+  Choice "implicitPrelude" ->+  [LImportDecl GhcPs] ->+  [[LImportDecl GhcPs]]+normalizeImports groupImportsOpts localModules implicitPrelude =   map (fmap snd)     . concatMap-      ( groupImports importGrouping localModules toImport+      ( groupImports groupImportsOpts localModules toImport           . M.toAscList           . M.fromListWith combineImports-          . fmap (\x -> (importId x, g x))+          . fmap (\x -> (importId implicitPrelude x, g x))       )-    . prepareExistingGroups importGrouping respectful+    . prepareExistingGroups groupImportsOpts   where     toImport :: (ImportId, x) -> Import-    toImport (ImportId {..}, _) = Import {importName = importIdName, importQualified}+    toImport (ImportId {..}, _) =+      Import+        { importName = importIdName,+          importList = case importHiding of+            Just (ImportListInterpretationOrd Exactly) -> Just ImportList+            Just (ImportListInterpretationOrd EverythingBut) -> Just HidingList+            Nothing -> Nothing,+          importQualified+        }      g :: LImportDecl GhcPs -> LImportDecl GhcPs     g (L l ImportDecl {..}) =@@ -68,20 +85,41 @@   LImportDecl GhcPs ->   LImportDecl GhcPs ->   LImportDecl GhcPs-combineImports (L lx ImportDecl {..}) (L _ y) =-  L-    lx-    ImportDecl-      { ideclImportList = case (ideclImportList, GHC.ideclImportList y) of-          (Just (hiding, L l' xs), Just (_, L _ ys)) ->-            Just (hiding, (L l' (normalizeLies (xs ++ ys))))-          _ -> Nothing,-        ..-      }+combineImports x y =+  L widenedLoc earlier {ideclImportList = combinedImportList}+  where+    -- The merged declaration spans both of the ones it came from, so that+    -- it is laid out over several lines and a comment that was written+    -- between them has somewhere to go. Its own span would otherwise still+    -- describe a single line.+    widenedLoc =+      l {entry = EpaSpan (combineSrcSpans (locA (getLoc x)) (locA (getLoc y)))} --- | Import id, a collection of all things that justify having a separate--- import entry. This is used for merging of imports. If two imports have--- the same 'ImportId' they can be merged.+    -- Take the declaration that comes first in the source whole, rather+    -- than mixing the span of one with the contents of the other: a+    -- declaration whose span sits before its own module name or import+    -- list cannot be placed in a containment tree, which is what comment+    -- attachment needs.+    (L l earlier, L _ later)+      | startsFirst (locA (getLoc x)) (locA (getLoc y)) = (x, y)+      | otherwise = (y, x)+    combinedImportList =+      case (GHC.ideclImportList earlier, GHC.ideclImportList later) of+        (Just (hiding, L l' xs), Just (_, L _ ys)) ->+          Just (hiding, L l' (normalizeLies (xs ++ ys)))+        _ -> Nothing++-- | Does the first span start before the second? Spans without a real+-- location are treated as coming first, arbitrarily but consistently.+startsFirst :: SrcSpan -> SrcSpan -> Bool+startsFirst a b = case (srcSpanToRealSrcSpan a, srcSpanToRealSrcSpan b) of+  (Just a', Just b') -> realSrcSpanStart a' <= realSrcSpanStart b'+  (Nothing, _) -> True+  _ -> False++-- | An import id, a collection of all the things that justify having a+-- separate import entry. This is used for merging imports: if two imports+-- have the same 'ImportId', they can be merged. data ImportId = ImportId   { importIsPrelude :: Bool,     importPkgQual :: ImportPkgQual,@@ -90,10 +128,23 @@     importSafe :: Bool,     importQualified :: Bool,     importAs :: Maybe ModuleName,-    importHiding :: Maybe ImportListInterpretationOrd+    importHiding :: Maybe ImportListInterpretationOrd,+    importLevel :: Maybe ImportDeclLevelOrd   }   deriving (Eq, Ord) +-- | A wrapper for 'ImportDeclLevel' that provides an 'Ord' instance.+newtype ImportDeclLevelOrd = ImportDeclLevelOrd+  { unImportDeclLevelOrd :: ImportDeclLevel+  }+  deriving stock (Eq)++instance Ord ImportDeclLevelOrd where+  compare = compare `on` toBool . unImportDeclLevelOrd+    where+      toBool ImportDeclSplice = False+      toBool ImportDeclQuote = True+ data ImportPkgQual   = -- | The import is not qualified by a package name.     NoImportPkgQual@@ -124,8 +175,8 @@       toBool EverythingBut = True  -- | Obtain an 'ImportId' for a given import.-importId :: LImportDecl GhcPs -> ImportId-importId (L _ ImportDecl {..}) =+importId :: Choice "implicitPrelude" -> LImportDecl GhcPs -> ImportId+importId implicitPrelude (L _ ImportDecl {..}) =   ImportId     { importIsPrelude = isPrelude,       importIdName = moduleName,@@ -137,11 +188,17 @@         QualifiedPost -> True         NotQualified -> False,       importAs = unLoc <$> ideclAs,-      importHiding = ImportListInterpretationOrd . fst <$> ideclImportList+      importHiding = ImportListInterpretationOrd . fst <$> ideclImportList,+      importLevel = importLevelOf ideclLevelSpec     }   where-    isPrelude = moduleNameString moduleName == "Prelude"+    isPrelude =+      Choice.isTrue implicitPrelude && moduleNameString moduleName == "Prelude"     moduleName = unLoc ideclName+    importLevelOf = \case+      LevelStylePre l -> Just (ImportDeclLevelOrd l)+      LevelStylePost l -> Just (ImportDeclLevelOrd l)+      NotLevelled -> Nothing  -- | Normalize a collection of import items. normalizeLies :: [LIE GhcPs] -> [LIE GhcPs]@@ -221,7 +278,7 @@ compareLIewn :: LIEWrappedName GhcPs -> LIEWrappedName GhcPs -> Ordering compareLIewn = compareIewn `on` unLoc --- | Compare two @'IEWrapppedName' 'GhcPs'@ things.+-- | Compare two @'IEWrappedName' 'GhcPs'@ things. compareIewn :: IEWrappedName GhcPs -> IEWrappedName GhcPs -> Ordering compareIewn = (comparing fst <> (compareRdrName `on` unLoc . snd)) `on` classify   where@@ -231,6 +288,7 @@       IEDefault _ x -> (1, x)       IEPattern _ x -> (2, x)       IEType _ x -> (3, x)+      IEData _ x -> (4, x)  compareRdrName :: RdrName -> RdrName -> Ordering compareRdrName x y =

@@ -1,8 +1,12 @@ {-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedRecordDot #-} {-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE NoFieldSelectors #-}  module Ormolu.Imports.Grouping   ( Import (..),+    ImportList (..),+    GroupImportsOpts (..),     prepareExistingGroups,     groupImports,   )@@ -14,23 +18,32 @@ import Data.List (groupBy, minimumBy, sortOn) import Data.List.NonEmpty (NonEmpty) import Data.List.NonEmpty qualified as NonEmpty+import Data.Map qualified as Map+import Data.Maybe (fromMaybe) import Data.Set (Set) import Data.Set qualified as Set import Distribution.ModuleName qualified as Cabal-import GHC.Hs (GhcPs, getLocA)+import GHC.Hs (GhcPs, LEpaComment, epaLocationRealSrcSpan, getLocA)+import GHC.Types.SrcLoc (getLoc, srcSpanEndLine, srcSpanStartLine, srcSpanToRealSrcSpan) import Language.Haskell.Syntax (LImportDecl, ModuleName, moduleNameString)-import Ormolu.Config (ImportGroup (..), ImportGroupRule (..), ImportGrouping (..), ImportModuleMatcher (..))+import Ormolu.Config (ImportGroup (..), ImportGroupRule (..), ImportGrouping (..)) import Ormolu.Config qualified as Config-import Ormolu.Utils (ghcModuleNameToCabal, groupBy', separatedByBlank)-import Ormolu.Utils.Glob (matchesGlob)+import Ormolu.Utils (ghcModuleNameToCabal, groupBy')+import Ormolu.Utils.Glob (matchAllGlob, matchesGlob)  newtype ImportGroups = ImportGroups (NonEmpty ImportGroup)  data Import = Import   { importName :: ModuleName,+    importList :: Maybe ImportList,     importQualified :: Bool   } +data ImportList+  = ImportList+  | HidingList+  deriving (Eq)+ importGroupSingleStrategy :: ImportGroups importGroupSingleStrategy =   ImportGroups $@@ -94,16 +107,20 @@ matchAllImportRule :: ImportGroupRule matchAllImportRule =   ImportGroupRule-    { igrModuleMatcher = MatchAllModules,+    { igrGlob = matchAllGlob,+      igrImportListMatcher = Config.MatchAnyImportDeclaration,       igrQualifiedMatcher = Config.MatchBothQualifiedAndUnqualified,+      igrScopeMatcher = Config.MatchAllModules,       igrPriority = Config.matchAllRulePriority     }  matchLocalModulesRule :: ImportGroupRule matchLocalModulesRule =   ImportGroupRule-    { igrModuleMatcher = MatchLocalModules,+    { igrGlob = matchAllGlob,+      igrImportListMatcher = Config.MatchAnyImportDeclaration,       igrQualifiedMatcher = Config.MatchBothQualifiedAndUnqualified,+      igrScopeMatcher = Config.MatchLocalModules,       igrPriority = Config.matchLocalRulePriority     } @@ -122,31 +139,78 @@     }  matchesRule :: Set Cabal.ModuleName -> Import -> ImportGroupRule -> Bool-matchesRule localMods Import {..} ImportGroupRule {..} = matchesModules && matchesQualified+matchesRule localMods Import {..} ImportGroupRule {..} =+  and+    [ matchingGlob,+      matchingImportList,+      matchingQualified,+      matchingScope+    ]   where-    matchesModules = case igrModuleMatcher of-      MatchAllModules -> True-      MatchLocalModules -> ghcModuleNameToCabal importName `Set.member` localMods-      MatchGlob gl -> moduleNameString importName `matchesGlob` gl-    matchesQualified = case igrQualifiedMatcher of+    matchingGlob = moduleNameString importName `matchesGlob` igrGlob+    matchingImportList = case igrImportListMatcher of+      Config.MatchExplicitImportList -> importList == Just ImportList+      Config.MatchHidingImportClause -> importList == Just HidingList+      Config.MatchWholeModuleImport -> importList == Nothing+      Config.MatchAnyImportDeclaration -> True+    matchingQualified = case igrQualifiedMatcher of       Config.MatchQualifiedOnly -> importQualified       Config.MatchUnqualifiedOnly -> not importQualified       Config.MatchBothQualifiedAndUnqualified -> True+    matchingScope =+      let isLocalModule = ghcModuleNameToCabal importName `Set.member` localMods+       in case igrScopeMatcher of+            Config.MatchAllModules -> True+            Config.MatchExternalModules -> not isLocalModule+            Config.MatchLocalModules -> isLocalModule -prepareExistingGroups :: ImportGrouping -> Bool -> [LImportDecl GhcPs] -> [[LImportDecl GhcPs]]-prepareExistingGroups ig respectful =-  case ig of+data GroupImportsOpts = GroupImportsOpts+  { grouping :: ImportGrouping,+    respectful :: Bool,+    -- | All comments in the HsModule.+    --+    -- Can't retrieve comments from 'R', since 'R' runs the first time without+    -- comments.+    allComments :: [LEpaComment]+  }++prepareExistingGroups :: GroupImportsOpts -> [LImportDecl GhcPs] -> [[LImportDecl GhcPs]]+prepareExistingGroups opts =+  case opts.grouping of     ImportGroupPreserve -> preserveGroups-    ImportGroupLegacy | respectful -> preserveGroups+    ImportGroupLegacy | opts.respectful -> preserveGroups     _ -> flattenGroups   where-    preserveGroups = map toList . groupBy' (\x y -> not $ separatedByBlank getLocA x y)+    preserveGroups = map toList . groupBy' (\x y -> not $ separatedByBlank' x y)     flattenGroups = pure -groupImports :: forall x. ImportGrouping -> Set Cabal.ModuleName -> (x -> Import) -> [x] -> [[x]]-groupImports ig localModules fToImport = regroup . fmap (breakTies . matchRules)+    -- separatedByBlank only checks if the span lines are more than 1 apart.+    -- If there's a comment between two imports with no blank lines, we should+    -- still consider it one import group.+    separatedByBlank' a b =+      fromMaybe False $ do+        endA <- srcSpanEndLine <$> srcSpanToRealSrcSpan (getLocA a)+        startB <- srcSpanStartLine <$> srcSpanToRealSrcSpan (getLocA b)+        pure . any (not . hasComment) $ [endA + 1 .. startB - 1]++    -- Maps startLine -> endLine+    commentLineIntervals =+      Map.fromList+        [ (srcSpanStartLine spn, srcSpanEndLine spn)+        | comment <- opts.allComments,+          let spn = epaLocationRealSrcSpan $ getLoc comment+        ]+    hasComment lineNum =+      (not . Map.null)+        -- Find any comment where: startLine <= lineNum <= endLine+        . Map.filter (>= lineNum)+        . Map.takeWhileAntitone (<= lineNum)+        $ commentLineIntervals++groupImports :: forall x. GroupImportsOpts -> Set Cabal.ModuleName -> (x -> Import) -> [x] -> [[x]]+groupImports opts localModules fToImport = regroup . fmap (breakTies . matchRules)   where-    ImportGroups igs = groupsFromConfig ig+    ImportGroups igs = groupsFromConfig opts.grouping      indexedGroupRules :: [(Int, [ImportGroupRule])]     indexedGroupRules = zip [0 ..] (toList . igRules <$> toList igs)