Fix parsing of nested when expressions

Author: robinheghan

src/Compiler/Parse/Context.gren

@@ -17,7 +17,7 @@ type alias Context =
 
 empty : Context
 empty =
-    { indent = 0
+    { indent = 1
     , comments = Dict.empty
     }
 

src/Compiler/Parse/Expression.gren

@@ -301,10 +301,6 @@ letDefNamedParser =
                                 |> Parser.skip spaceParser
                                 |> Parser.keep
                                     (Type.expression
-                                        |> Parser.scopedUpdatePayload
-                                            var.start.col
-                                            .indent
-                                            (\nextValue payload -> { payload | indent = nextValue })
                                         |> Parser.mapError TypeError
                                     )
                                 |> Parser.skip
@@ -321,12 +317,17 @@ letDefNamedParser =
                                                 else
                                                     Parser.succeed {}
                                             )
-                                
+                            
                                     )
                                 |> Parser.skip spaceParser
                             , Parser.succeed Nothing
                             ]
                         )
+                    -- TODO: How to reverse this?
+                    |> Parser.scopedUpdatePayload
+                        var.start.col
+                        .indent
+                        (\nextValue payload -> { payload | indent = nextValue })
                     |> Parser.keep (Parser.loop [] (functionArgsParser "="))
                     |> Parser.skip spaceParser
                     |> Parser.keep (Parser.lazy (\_ -> parser))
@@ -446,6 +447,10 @@ whenParser =
                                 endLocation
                                 (AST.When { expression = expr, branches = branches })
                         )
+                    |> Parser.scopedUpdatePayload
+                        start.col
+                        .indent
+                        (\value payload -> { payload | indent = value })
             )
 
 whenBranchParser : Parser Context Error AST.WhenBranch
@@ -456,7 +461,6 @@ whenBranchParser =
         |> Parser.skip (Parser.keyword "->" (ExpectedKeyword "->"))
         |> Parser.skip spaceParser
         |> Parser.keep (Parser.lazy (\_ -> parser))
-        |> Parser.skip spaceParser
 
 
 whenBranchLoopParser : Array AST.WhenBranch -> Parser Context Error (Parser.Step (Array AST.WhenBranch) (Array AST.WhenBranch))

src/Compiler/Parse/Pattern.gren

@@ -179,6 +179,7 @@ term =
                     |> Parser.keep
                         (Parser.oneOf
                             [ Parser.lazy (\_ -> parser)
+                                -- TODO: why backtrackable?
                                 |> Parser.backtrackable
                                 |> Parser.map Just
                             , Parser.succeed Nothing
@@ -193,7 +194,7 @@ term =
                                         , arg = arg
                                         }
 
-                                Variable.Qualified { module_, name  } ->
+                                Variable.Qualified { module_, name } ->
                                     AST.PCtorQual
                                         { varRegion = { start = start, end = end }
                                         , module_ = module_
@@ -225,6 +226,29 @@ term =
             )
         |> Parser.keep Parser.getPosition
         |> Parser.skip spaceParser
+        -- Correct positions of Constructors
+        |> Parser.map
+            (\t ->
+                when t is
+                    { value = AST.PCtor { name, arg } } ->
+                        { start = t.start
+                        , value = t.value
+                        , end =
+                            Maybe.map .end arg
+                                |> Maybe.withDefault name.end
+                        }
+
+                    { value = AST.PCtorQual { varRegion, arg } } ->
+                        { start = t.start
+                        , value = t.value
+                        , end =
+                            Maybe.map .end arg
+                                |> Maybe.withDefault varRegion.end
+                        }
+
+                    _ ->
+                        t
+            )
 
 
 lowerCaseVariable : Parser Context Error String

src/Compiler/Parse/Space.gren

@@ -84,7 +84,7 @@ checkIndent =
         |> Parser.keep Parser.getCol
         |> Parser.andThen
             (\{ indent, col } ->
-                if col > indent && col > 1 then
+                if col > indent then
                     Parser.succeed {}
 
                 else

src/Compiler/Parse/Type.gren

@@ -61,15 +61,21 @@ expression =
                                 next.end
                                 (AST.TLambda { from = tipe, to = next })
                         )
-                        |> Parser.skip (Parser.mapError (\_ -> ExpectedIndent) Space.checkIndent)
+                        |> Parser.skip checkIndent
                         |> Parser.skip (Parser.token "->" (ExpectedString "->"))
                         |> Parser.skip spaceParser
+                        |> Parser.skip checkIndent
                         |> Parser.keep (Parser.lazy (\_ -> expression))
                     , Parser.succeed tipe
                     ]
             )
 
 
+checkIndent : Parser Context Error {}
+checkIndent =
+    Parser.mapError (\_ -> ExpectedIndent) Space.checkIndent
+
+
 app : Parser Context Error AST.Type
 app =
     Parser.succeed