Parse trailling comma & multiline

src/Nirum/Parser.hs

@@ -39,7 +39,6 @@ import qualified System.IO as SIO
 
 import qualified Data.List as L
 import Data.Map.Strict as Map hiding (foldl, toList)
-import Data.Maybe
 import Data.Set hiding (foldl)
 import qualified Data.Text as T
 import qualified Data.Text.IO as TIO
@@ -635,14 +634,16 @@ importName forwardNames = do
     aSet <- annotationSet <?> "import annotations"
     spaces
     iName <- identifier <?> "name to import"
-    aName <- optional $ try $ do
-      spaces
-      string' "as"
-      spaces
-      n <- uniqueIdentifier forwardNames "alias name to import"
-      spaces
-      return n
-    return (iName, fromMaybe iName aName, aSet)
+    hasAlias <- optional $ try $ do
+        spaces
+        string' "as"
+    aName <- case hasAlias of
+        Just _ -> do
+            spaces
+            uniqueIdentifier forwardNames "alias name to import"
+        Nothing ->
+            return iName
+    return (aName, iName, aSet)
 
 imports :: [Identifier] -> Parser [TypeDeclaration]
 imports forwardNames = do
@@ -653,18 +654,22 @@ imports forwardNames = do
     char '('
     spaces
     idents <- many' [] $ \ importNames' -> do
-        let forwardNames' = [ i | (_, i, _) <- importNames' ] ++
+        notFollowedBy $ choice [char ')', char ',' >> spaces >> char ')']
+        let forwardNames' = [ i | (i, _, _) <- importNames' ] ++
                 forwardNames
         unless (L.null importNames') $ do
             string' ","
             spaces
-        i <- importName forwardNames'
+        n <- importName forwardNames'
         spaces
-        return i
+        return n
+    when (L.null idents) $ fail "parentheses cannot be empty"
+    void $ optional $ string' ","
+    spaces
     char ')'
     spaces
     char ';'
-    return [ Import path source imp aSet
+    return [ Import path imp source aSet
            | (imp, source, aSet) <- idents
            ]
 

test/Nirum/ParserSpec.hs

@@ -1216,36 +1216,46 @@ service method-dups (
                 [ Import ["foo", "bar"] "foo" "c" empty
                 , Import ["foo", "bar"] "bar" "d" empty
                 ]
+
         it "errors if parentheses have nothing" $
             expectError "import foo.bar ();" 1 17
+        it "disallows when there are duplicated alias names" $
+            expectError "import foo.bar (lorem as yolo, ipsum as yolo);" 1 41
 
-    describe "module'" $ context "handling name duplications" $ do
-        let (_, expectError) = helperFuncs P.module'
-        let examples =
-                -- Vertical alignment of `dup` is an intention; it purposes
-                -- to generate the same error offsets.
-                [ "type       dup = text;"
-                , "unboxed    dup (text);"
-                , "record     dup (text a);"
-                , "enum       dup = m1 | m2;"
-                , "enum e1 =  dup | foo;"
-                , "union      dup = t1 | t2;"
-                , "union u1 = dup | foo;"
-                , "service    dup (text ping ());"
-                ]
-        let importExample = "import foo (dup);"
-        let shiftDigit = \ case
-                '1' -> '3'
-                '2' -> '4'
-                c -> c
-        let inputs = [ (a, if a == b then T.map shiftDigit b else b)
-                     | a <- importExample : examples
-                     , b <- examples
-                     ]
-        forM_ inputs $ \ (forward, shadowing) ->
-            let input = T.concat [forward, "\n", shadowing]
-            in
-                specify (T.unpack input) $ expectError input 2 12
+    describe "module'" $ do
+        context "handling name duplications" $ do
+            let (_, expectError) = helperFuncs P.module'
+            let examples =
+                    -- Vertical alignment of `dup` is an intention; it purposes
+                    -- to generate the same error offsets.
+                    [ "type       dup = text;"
+                    , "unboxed    dup (text);"
+                    , "record     dup (text a);"
+                    , "enum       dup = m1 | m2;"
+                    , "enum e1 =  dup | foo;"
+                    , "union      dup = t1 | t2;"
+                    , "union u1 = dup | foo;"
+                    , "service    dup (text ping ());"
+                    ]
+            let importExample = "import foo (dup);"
+            let shiftDigit = \ case
+                    '1' -> '3'
+                    '2' -> '4'
+                    c -> c
+            let inputs = [ (a, if a == b then T.map shiftDigit b else b)
+                         | a <- importExample : examples
+                         , b <- examples
+                         ]
+            forM_ inputs $ \ (forward, shadowing) ->
+                let input = T.concat [forward, "\n", shadowing]
+                in
+                    specify (T.unpack input) $ expectError input 2 12
+        specify "allows import duplicated source name when it use alias" $ do
+            let (parse', _) = helperFuncs P.module'
+            parse' "import foo.bar (a);\n import lorem.ipsum (a as dolor);" `shouldBeRight`
+                Module [ Import ["foo", "bar"] "a" "a" empty
+                       , Import ["lorem", "ipsum"] "dolor" "a" empty
+                       ] Nothing
 
     specify "parse & parseFile" $ do
         files <- getDirectoryContents "examples"