Fix parser indentation check after ‘export’

5 files changed, 107 insertions, 18 deletions

diff --git a/src/Parser.hs b/src/Parser.hs
index b2d666c..0716457 100644
--- a/src/Parser.hs
+++ b/src/Parser.hs
@@ -49,9 +49,9 @@ parseTestDefinition = label "test definition" $ toplevel ToplevelTest $ do
         wsymbol "test"
         lexeme $ TL.toStrict <$> takeWhileP (Just "test name") (/=':')
 
-parseDefinition :: TestParser ( VarName, SomeExpr )
-parseDefinition = label "symbol definition" $ do
-    def@( name, expr ) <- localState $ L.indentBlock scn $ do
+parseDefinition :: Pos -> TestParser ( VarName, SomeExpr )
+parseDefinition href = label "symbol definition" $ do
+    def@( name, expr ) <- localState $ do
         wsymbol "def"
         name <- varName
         argsDecl <- functionArguments (\off _ -> return . ( off, )) varName mzero (\_ -> return . VarName)
@@ -59,19 +59,20 @@ parseDefinition = label "symbol definition" $ do
             tvar <- newTypeVar
             modify $ \s -> s { testVars = ( vname, ( LocalVarName vname, ExprTypeVar tvar )) : testVars s }
             return ( off, vname, tvar )
-        choice
+        SomeExpr expr <- choice
             [ do
                 osymbol ":"
-                let finish steps = do
-                        atypes' <- getInferredTypes atypes
-                        ( name, ) . SomeExpr . ArgsReq atypes' . FunctionAbstraction <$> replaceDynArgs (mconcat steps)
-                return $ L.IndentSome Nothing finish testStep
+                scn
+                ref <- L.indentGuard scn GT href
+                SomeExpr <$> blockOf ref testStep
             , do
                 osymbol "="
-                SomeExpr (expr :: Expr e) <- someExpr
-                atypes' <- getInferredTypes atypes
-                L.IndentNone . ( name, ) . SomeExpr . ArgsReq atypes' . FunctionAbstraction <$> replaceDynArgs expr
+                someExpr <* eol
             ]
+        scn
+        atypes' <- getInferredTypes atypes
+        sexpr <- SomeExpr . ArgsReq atypes' . FunctionAbstraction <$> replaceDynArgs expr
+        return ( name, sexpr )
     modify $ \s -> s { testVars = ( name, ( GlobalVarName (testCurrentModuleName s) name, someExprType expr )) : testVars s }
     return def
   where
@@ -100,13 +101,13 @@ parseDefinition = label "symbol definition" $ do
                 replaceArgs (SomeExpr e) = SomeExpr (go unif e)
             e -> e
 
-parseAsset :: TestParser ( VarName, SomeExpr )
-parseAsset = label "asset definition" $ do
+parseAsset :: Pos -> TestParser ( VarName, SomeExpr )
+parseAsset href = label "asset definition" $ do
     wsymbol "asset"
     name <- varName
     osymbol ":"
     void eol
-    ref <- L.indentGuard scn GT pos1
+    ref <- L.indentGuard scn GT href
 
     wsymbol "path"
     osymbol ":"
@@ -126,10 +127,11 @@ parseAsset = label "asset definition" $ do
 
 parseExport :: TestParser [ Toplevel ]
 parseExport = label "export declaration" $ toplevel id $ do
+    ref <- L.indentLevel
     wsymbol "export"
     choice
       [ do
-        def@( name, _ ) <- parseDefinition <|> parseAsset
+        def@( name, _ ) <- parseDefinition ref <|> parseAsset ref
         return [ ToplevelDefinition def, ToplevelExport name ]
       , do
         names <- listOf varName
@@ -164,8 +166,8 @@ parseTestModule absPath = do
     modify $ \s -> s { testCurrentModuleName = moduleName }
     toplevels <- fmap concat $ many $ choice
         [ (: []) <$> parseTestDefinition
-        , (: []) <$> toplevel ToplevelDefinition parseDefinition
-        , (: []) <$> toplevel ToplevelDefinition parseAsset
+        , (: []) <$> toplevel ToplevelDefinition (parseDefinition pos1)
+        , (: []) <$> toplevel ToplevelDefinition (parseAsset pos1)
         , parseExport
         , parseImport
         ]
diff --git a/test/asset/definition/basic.et b/test/asset/definition/basic.et
new file mode 100644
index 0000000..6ae248e
--- /dev/null
+++ b/test/asset/definition/basic.et
@@ -0,0 +1,22 @@
+def expr_def = 4
+
+def fun_expr_def (x) = x + 5
+
+def test_def (n):
+    shell as p on n:
+	echo $expr_def
+
+    expect from p:
+	/4/
+
+def fun_test_def (n) first x:
+    shell as p on n:
+	echo ${expr_def + x}
+
+    expect from p:
+	/${4 + x}/
+
+test Test:
+    node n
+    test_def (n)
+    fun_test_def (n) first 7
diff --git a/test/asset/parser/indent.et b/test/asset/parser/indent.et
new file mode 100644
index 0000000..01c4dd8
--- /dev/null
+++ b/test/asset/parser/indent.et
@@ -0,0 +1,41 @@
+def x1s:
+ wait
+
+def x2s:
+  wait
+
+def x4s:
+    wait
+
+def x8s:
+        wait
+
+def x16s:
+                wait
+
+def x1t:
+	wait
+
+def x2t:
+		wait
+
+export def e1s:
+ wait
+
+export def e2s:
+  wait
+
+export def e4s:
+    wait
+
+export def e8s:
+        wait
+
+export def e16s:
+                wait
+
+export def e1t:
+	wait
+
+export def e2t:
+		wait
diff --git a/test/script/definition.et b/test/script/definition.et
new file mode 100644
index 0000000..d2da737
--- /dev/null
+++ b/test/script/definition.et
@@ -0,0 +1,18 @@
+module definition
+
+asset scripts:
+    path: ../asset/definition
+
+test Definition:
+    spawn as p 
+    with p:
+        send "load ${scripts.path}/basic.et"
+        expect /load-done/
+
+        send "run Test"
+        expect /child-stdout p 4/
+        expect /match p 4/
+        expect /child-stdout p 11/
+        expect /match p 11/
+        expect /(.*)/ capture done
+        guard (done == "run-done")
diff --git a/test/script/parser.et b/test/script/parser.et
index ee99989..554e345 100644
--- a/test/script/parser.et
+++ b/test/script/parser.et
@@ -1,7 +1,13 @@
 module parser
 
-test ModuleNotFound:
+asset scripts:
+    path: ../asset/parser
+
+test Parser:
     spawn as p 
     with p:
         send "load non-existing-file.et"
         expect /load-failed file-not-found .*/
+
+        send "load ${scripts.path}/indent.et"
+        expect /load-done/