Use shared dependency for rendering

.hlint.yaml

@@ -1 +1,5 @@
+- ignore: {name: "Avoid lambda using `infix`"}
 - ignore: {name: "Eta reduce"}
+- ignore: {name: "Use :"}
+- ignore: {name: "Use <$>"}
+- ignore: {name: "Use record patterns"}

CHANGELOG.md

@@ -1,3 +1,9 @@
+## dev
+
+Format changes:
+  - Multi-line `import` statements are now formatted slightly different (and with less indentation)
+
+
 ## 0.8.7
 
 New features:
@@ -117,7 +123,7 @@ Bug fixes:
   - On Windows, special folders are now correctly skipped when traversing the filesystem
   - Initial comments in doc comment code blocks are no longer removed
 
-Syntax changes:
+Format changes:
   - Infix operator precedence and associativity declarations are now grouped together
   - `if` expressions now have blank lines between clauses
   - Comments immediately following `import`s now have spacing consistent with other top-level comments
@@ -161,7 +167,7 @@ Other changes:
 Notes:
   - Support for Elm 0.16 is deprecated (but is still available with the `--elm-version=0.16` option).
 
-Syntax changes:
+Format changes:
   - Removed a workaround for an Elm 0.16 compiler bug that added extra parenthesis to qualified type tags in pattern matches
   - End-of-line `--` comments are now kept on their original line when appropriate
   - `--` comments in the middle of binary operator sequences no longer push the following expression to the next line
@@ -210,7 +216,7 @@ Bug fixes:
 
 ## 0.4.0-alpha
 
-Syntax changes:
+Format changes:
   - multiline expressions with long infix operators now indent in a more appropriate way
   - The `<|` operator is now handled specially and is placed at the end of the preceding line
   - line breaks are now allowed before the first arguments to functions

elm-format-lib/elm-format-lib.cabal

@@ -40,6 +40,7 @@ library
   other-modules:
       AST.Helpers
       Box
+      Box.BlockAdapter
       Data.Utf8
       Elm.String
       ElmFormat.AST.BinaryOperatorPrecedence
@@ -111,6 +112,7 @@ test-suite efl-tests
       BoxTest
       ElmFormat.AST.BinaryOperatorPrecedenceTest
       ElmFormat.ImportInfoTest
+      ElmFormat.Render.BoxTest
       ElmFormat.Render.ElmStructureTest
       Parse.ExpressionTest
       Parse.HelpersTest
@@ -126,6 +128,7 @@ test-suite efl-tests
       AST.Structure
       AST.V0_16
       Box
+      Box.BlockAdapter
       CommandLine.InfoFormatter
       CommandLine.Program
       CommandLine.ResolveFiles

elm-format-lib/src/AST/Structure.hs

@@ -1,9 +1,7 @@
 {-# LANGUAGE Rank2Types #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE UndecidableInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE PolyKinds #-}
 
@@ -88,7 +86,7 @@ foldReferences ftype fctor fvar =
             Parens e -> extract e
             ExplicitList terms _ _ -> fold terms
             Range left right _ -> extract left <> extract right
-            Tuple terms _ -> mconcat $ fmap extract terms
+            Tuple terms _ _ -> fold terms
             TupleFunction _ -> mempty
             Record _ fields _ _ -> foldMap (extract . _value) fields
             Access e _ -> e

elm-format-lib/src/AST/V0_16.hs

@@ -374,8 +374,10 @@ data AST typeRef ctorRef varRef (getType :: NodeKind -> Type) (kind :: NodeKind)
         -> AST typeRef ctorRef varRef getType 'ExpressionNK
 
     Tuple ::
-        [C2 'BeforeTerm 'AfterTerm (getType 'ExpressionNK)]
-        -> Bool
+        { terms :: Sequence (getType 'ExpressionNK)
+        , trailingComments_t :: Comments
+        , forceMultiline_t :: ForceMultiline
+        }
         -> AST typeRef ctorRef varRef getType 'ExpressionNK
     TupleFunction ::
         Int -- will be 2 or greater, indicating the number of elements in the tuple
@@ -579,7 +581,7 @@ mapAll ftyp fctor fvar fast = \case
     Parens e -> Parens (fmap fast e)
     ExplicitList terms c ml -> ExplicitList (fmap fast terms) c ml
     Range left right ml -> Range (fmap fast left) (fmap fast right) ml
-    Tuple terms ml -> Tuple (fmap (fmap fast) terms) ml
+    Tuple terms c ml -> Tuple (fmap fast terms) c ml
     TupleFunction n -> TupleFunction n
     Record base fields c ml -> Record base (fmap (fmap fast) fields) c ml
     Access e field -> Access (fast e) field

elm-format-lib/src/Box.hs

@@ -1,15 +1,19 @@
 {-# OPTIONS_GHC -Wall #-}
 module Box
   ( Line, identifier, keyword, punc, literal, row, space
-  , Box(SingleLine, MustBreak), blankLine, line, mustBreak, stack', stack1, andThen
+  , Box(SingleLine, MustBreak), blankLine, line, mustBreak, stack1, andThen
   , isLine, allSingles, lineLength
   , indent, prefix, addSuffix
-  , render
+  , render, renderLine
+  , joinMustBreak, prefixOrIndent, rowOrStackForce, rowOrIndentForce
   ) where
 
 import Elm.Utils ((|>))
 
 import qualified Data.Text as T
+import qualified Data.List.NonEmpty as NonEmpty
+import Data.List.NonEmpty (NonEmpty(..))
+import Data.List (intersperse)
 
 
 {-
@@ -25,6 +29,10 @@ data Line
     | Row [Line]
     | Space
     | Tab
+    deriving (Eq, Show)
+
+instance Semigroup Line where
+  (<>) a b = Row [ a, b ]
 
 
 identifier :: String -> Line
@@ -77,6 +85,7 @@ data Box
     = SingleLine Line
     | Stack Line Line [Line]
     | MustBreak Line
+    deriving (Eq, Show)
 
 
 blankLine :: Box
@@ -163,13 +172,20 @@ destructure b =
             (l1, [])
 
 
-allSingles :: [Box] -> Either [Box] [Line]
+allSingles :: [Box] -> Either [Box] ([Line], Bool)
 allSingles boxes =
-    case sequence $ map isLine boxes of
-        Right lines' ->
-            Right lines'
-        _ ->
-            Left boxes
+  allSingles' ([], True, False) (reverse boxes)
+  where
+    allSingles' (acc, _, isMustBreak) [] =
+      Right (acc, isMustBreak)
+    allSingles' (acc, isLast, isMustBreak) (next:rest) =
+      case next of
+        SingleLine l -> allSingles' (l:acc, False, isMustBreak) rest
+        MustBreak l ->
+          if isLast
+            then allSingles' (l:acc, False, True) rest
+            else Left boxes
+        Stack _ _ _ -> Left boxes
 
 
 {-
@@ -205,6 +221,73 @@ addSuffix suffix b =
                 |> andThen [ line $ row [ last ls, suffix ] ]
 
 
+joinMustBreak :: Box -> Box -> Box
+joinMustBreak inner eol =
+    case (inner, eol) of
+        (SingleLine inner', SingleLine eol') ->
+            SingleLine $ Row [ inner', space, eol' ]
+        (SingleLine inner', MustBreak eol') ->
+            MustBreak $ Row [ inner', space, eol' ]
+        _ ->
+            stack' inner eol
+
+
+prefixOrIndent :: Maybe Line -> Line -> Box -> Box
+prefixOrIndent joiner a b =
+   case b of
+      SingleLine b' ->
+        line $ join a b'
+      MustBreak b' ->
+        mustBreak $ join a b'
+      _ ->
+        stack' (line a) (indent b)
+  where
+      join a_ b_ =
+        case joiner of
+          Nothing -> Row [ a_, b_ ]
+          Just j -> Row [ a_, j, b_ ]
+
+
+rowOrStackForce :: Bool -> Maybe Line -> NonEmpty Box -> Box
+rowOrStackForce _ _ (single :| []) = single
+rowOrStackForce forceMultiline joiner blocks =
+  case allSingles $ NonEmpty.toList blocks of
+    Right (lines_, isMustBreak)
+      | not forceMultiline ->
+          mkBlock $ mkRow lines_
+          where
+            mkBlock =
+              if isMustBreak
+                then mustBreak
+                else line
+            mkRow =
+              case joiner of
+                Just j -> Row . intersperse j
+                Nothing -> Row
+    _ ->
+      stack1 $ NonEmpty.toList blocks
+
+
+rowOrIndentForce :: Bool -> Maybe Line -> NonEmpty Box -> Box
+rowOrIndentForce _ _ (single :| []) = single
+rowOrIndentForce forceMultiline joiner blocks@(b1 :| rest) =
+  case allSingles $ NonEmpty.toList blocks of
+    Right (lines_, isMustBreak)
+      | not forceMultiline ->
+          mkBlock $ mkRow lines_
+          where
+            mkBlock =
+              if isMustBreak
+                then mustBreak
+                else line
+            mkRow =
+              case joiner of
+                Just j -> Row . intersperse j
+                Nothing -> Row
+    _ ->
+      stack1 $ b1 : (indent <$> rest)
+
+
 renderLine :: Int -> Line -> T.Text
 renderLine startColumn line' =
     case line' of
@@ -255,7 +338,7 @@ spacesToNextTab startColumn =
 
 tabLength :: Int -> Int
 tabLength startColumn =
-  spacesInTab - (spacesToNextTab startColumn)
+  spacesInTab - spacesToNextTab startColumn
 
 {-
 What happens here is we take a row and start building its contents

elm-format-lib/src/Box/BlockAdapter.hs

@@ -0,0 +1,80 @@
+-- | This is a temporary module that mimics the https://hackage.haskell.org/package/prettyprint-avh4
+-- API using the current `Box` module.
+module Box.BlockAdapter where
+
+import qualified Box
+import Data.ByteString (ByteString)
+import qualified Data.ByteString.Builder as B
+import Data.List.NonEmpty (NonEmpty)
+import qualified Data.List.NonEmpty as NonEmpty
+import qualified Data.Text as Text
+import qualified Data.Text.Encoding as Text
+import qualified Data.Text.Lazy as Lazy
+import qualified Data.Text.Lazy.Encoding as Lazy
+
+type Line = Box.Line
+
+space :: Line
+space = Box.space
+
+string7 :: String -> Line
+string7 = Box.literal
+
+char7 :: Char -> Line
+char7 = Box.literal . pure
+
+stringUtf8 :: String -> Line
+stringUtf8 = Box.literal
+
+lineFromBuilder :: B.Builder -> Line
+lineFromBuilder = Box.literal . Lazy.unpack . Lazy.decodeUtf8 . B.toLazyByteString
+
+commentByteString :: ByteString -> Line
+commentByteString = Box.literal . Text.unpack . Text.decodeUtf8
+
+type Block = Box.Box
+
+render :: Block -> B.Builder
+render = Text.encodeUtf8Builder . Box.render
+
+blankLine :: Block
+blankLine = Box.blankLine
+
+line :: Line -> Block
+line = Box.line
+
+mustBreak :: Line -> Block
+mustBreak = Box.mustBreak
+
+stack :: NonEmpty Block -> Block
+stack = Box.stack1 . NonEmpty.toList
+
+andThen :: [Block] -> Block -> Block
+andThen = Box.andThen
+
+indent :: Block -> Block
+indent = Box.indent
+
+prefix :: Word -> Line -> Block -> Block
+prefix _ = Box.prefix
+
+addSuffix :: Line -> Block -> Block
+addSuffix = Box.addSuffix
+
+joinMustBreak :: Block -> Block -> Block
+joinMustBreak = Box.joinMustBreak
+
+prefixOrIndent :: Maybe Line -> Line -> Block -> Block
+prefixOrIndent = Box.prefixOrIndent
+
+rowOrStack :: Maybe Line -> NonEmpty Block -> Block
+rowOrStack = rowOrStackForce False
+
+rowOrStackForce :: Bool -> Maybe Line -> NonEmpty Block -> Block
+rowOrStackForce = Box.rowOrStackForce
+
+rowOrIndent :: Maybe Line -> NonEmpty Block -> Block
+rowOrIndent = rowOrIndentForce False
+
+rowOrIndentForce :: Bool -> Maybe Line -> NonEmpty Block -> Block
+rowOrIndentForce = Box.rowOrIndentForce

elm-format-lib/src/ElmFormat/AST/PublicAST/Expression.hs

@@ -231,9 +231,9 @@ instance ToPublicAST 'ExpressionNK where
             ListLiteral
                 ((\(C comments a) -> fromRawAST config a) <$> AST.toCommentedList terms)
 
-        AST.Tuple terms multiline ->
+        AST.Tuple terms comments multiline ->
             TupleLiteral
-                (fmap (\(C comments a) -> fromRawAST config a) terms)
+                ((\(C comments a) -> fromRawAST config a) <$> AST.toCommentedList terms)
 
         AST.TupleFunction n | n <= 1 ->
             error ("INVALID TUPLE CONSTRUCTOR: " ++ show n)
@@ -339,8 +339,9 @@ instance FromPublicAST 'ExpressionNK where
 
         TupleLiteral terms ->
             AST.Tuple
-                (C ([], []) . toRawAST <$> terms)
-                True
+                (Either.fromRight undefined $ AST.fromCommentedList $ C ([], [], Nothing) . toRawAST <$> terms)
+                []
+                (AST.ForceMultiline True)
 
         RecordLiteral base fields display ->
             AST.Record