tests: accept
authorJulien Moutinho <julm+symantic-parser@sourcephile.fr>
Tue, 31 Aug 2021 19:09:20 +0000 (21:09 +0200)
committerJulien Moutinho <julm+symantic-parser@sourcephile.fr>
Tue, 31 Aug 2021 19:09:20 +0000 (21:09 +0200)
test/Golden/Splice/G11.expected.txt
test/Golden/Splice/G12.expected.txt
test/Golden/Splice/G13.expected.txt
test/Golden/Splice/G14.expected.txt
test/Golden/Splice/G3.expected.txt
test/Golden/Splice/G4.expected.txt
test/Golden/Splice/G5.expected.txt
test/Golden/Splice/G8.expected.txt

index 2ad254bc622f2bbb4f0dc2f02a1c91f130ea6557..c2f934d45facabd7f85b9764dbf51864865fd1db 100644 (file)
                                                                                                               let dupv = \x -> sr ((GHC.Types.:) 'a' x)
                                                                                                               GHC.STRef.writeSTRef reg dupv
                                                                                                               let _ = "jump"
-                                                                                                               in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                               in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                         else
                                                                                           let _ = "checkToken.fail"
                                                                                            in let failExp =
index bb48ea913d52bedf4f5fefaaa25deb64db2fee17..b5849c1b715463c80ba4e8a8e123bb4fdf5b4bc0 100644 (file)
                                                                                                   let dupv = \x -> sr ((GHC.Types.:) c x)
                                                                                                   GHC.STRef.writeSTRef reg dupv
                                                                                                   let _ = "jump"
-                                                                                                   in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                   in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                             else
                                                                               let _ = "checkToken.fail"
                                                                                in let failExp =
index 361c87994d00c3e8680cd5db637948860ae83689..3c27ae473a2f1544c063617d4c936b34999beb9b 100644 (file)
                                                                                             let dupv = sr
                                                                                             GHC.STRef.writeSTRef reg dupv
                                                                                             let _ = "jump"
-                                                                                             in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                             in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                               else
                                                                                 let _ = "checkToken.fail"
                                                                                  in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty
                                                                                     let dupv = \x -> sr ((GHC.Types.:) v x)
                                                                                     GHC.STRef.writeSTRef reg dupv
                                                                                     let _ = "jump"
-                                                                                     in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                     in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                         )
                                                         inp
                                                         (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
index 5a393d052520e5e2ec95578d9f60efcd55172f24..53b3b7622857cc632c3ea3f1b2dddcbd38cac668 100644 (file)
                                                                                                                                                                                                                                                                                 let dupv = v v sr
                                                                                                                                                                                                                                                                                 GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                                                                                                                 let _ = "jump"
-                                                                                                                                                                                                                                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                                                                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                             )
                                                                                                                                                                                                                                                             inp
                                                                                                                                                                                                                                                             (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                     let dupv = v v sr
                                                                                                                                     GHC.STRef.writeSTRef reg dupv
                                                                                                                                     let _ = "jump"
-                                                                                                                                     in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                     in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                 )
                                                                                                                 inp
                                                                                                                 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                   let dupv = sr
                                                                                                                                                   GHC.STRef.writeSTRef reg dupv
                                                                                                                                                   let _ = "jump"
-                                                                                                                                                   in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                   in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                               )
                                                                                                                               inp
                                                                                                                               (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                 let dupv = sr
                                                                                                 GHC.STRef.writeSTRef reg dupv
                                                                                                 let _ = "jump"
-                                                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                             )
                                                                             callerInput
                                                                             (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                         let dupv = sr
                                                                                                                                                         GHC.STRef.writeSTRef reg dupv
                                                                                                                                                         let _ = "jump"
-                                                                                                                                                         in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                         in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                           else
                                                                                                                                             let _ = "checkToken.fail"
                                                                                                                                              in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty
                                                                                                                                                   let dupv = sr
                                                                                                                                                   GHC.STRef.writeSTRef reg dupv
                                                                                                                                                   let _ = "jump"
-                                                                                                                                                   in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                   in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                               )
                                                                                                                               callerInput
                                                                                                                               (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                 let dupv = sr
                                                                                                                                 GHC.STRef.writeSTRef reg dupv
                                                                                                                                 let _ = "jump"
-                                                                                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                in let _ = "catch ExceptionFailure checkedHorizon=0"
                                                                                                                    in let onException =
                                                                                                                             let _ = "onException"
                                                                                                                                                                                                                                                                                                                                                                                                                                                         let dupv = v v sr
                                                                                                                                                                                                                                                                                                                                                                                                                                                         GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                                                                                                                                                                                                                                                                                         let _ = "jump"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                         in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                         in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                                                                                                                                                                     )
                                                                                                                                                                                                                                                                                                                                                                                                                                     inp
                                                                                                                                                                                                                                                                                                                                                                                                                                     (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                                                                                                                                         callerInput
                                                                                                                                                                                                                                                                                                                                                                                                         Data.Map.Internal.Tip
                                                                                                                                                                                                                                                                                                                                                                                              in let _ = "jump"
-                                                                                                                                                                                                                                                                                                                                                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                                                                                                                                                                                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                                                                                                       )
                                                                                                                                                                                                                                                                                                                                                                       inp
                                                                                                                                                                                                                                                                                                                                                                       (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                                             let dupv = v v sr
                                                                                                                                                                                                                                                                                                             GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                                                                                                                                             let _ = "jump"
-                                                                                                                                                                                                                                                                                                             in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                                                                                                                                                                             in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                         )
                                                                                                                                                                                                                                                                                         inp
                                                                                                                                                                                                                                                                                         (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                             callerInput
                                                                                                                                                                                                                                                             Data.Map.Internal.Tip
                                                                                                                                                                                                                                                  in let _ = "jump"
-                                                                                                                                                                                                                                                     in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                                                                                                                     in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                           )
                                                                                                                                                                                                                           inp
                                                                                                                                                                                                                           (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                                                                                                                                               let dupv = sr
                                                                                                                                                                                                                                                                                                                                                                                                               GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                                                                                                                                                                                                                                               let _ = "jump"
-                                                                                                                                                                                                                                                                                                                                                                                                               in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                                                                                                                                                                                                                                                                                                                               in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                                                                                                                                                           )
                                                                                                                                                                                                                                                                                                                                                                                           inp
                                                                                                                                                                                                                                                                                                                                                                                           (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
index 916af310bef4094f5ca404c5e6660a85dfd805b8..d392781c800adf99af9de3027e0974b693897115 100644 (file)
                                                                                                   let dupv = \x -> sr ((GHC.Types.:) 'a' x)
                                                                                                   GHC.STRef.writeSTRef reg dupv
                                                                                                   let _ = "jump"
-                                                                                                   in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                   in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                             else
                                                                               let _ = "checkToken.fail"
                                                                                in let failExp =
index 9f1c25d0d54eda7680ee74d97927aced9692eba8..51e93e991654325bb8e80150a23fef3a8ab0cb6d 100644 (file)
                                                                                                       let dupv = \x -> sr ((GHC.Types.:) v x)
                                                                                                       GHC.STRef.writeSTRef reg dupv
                                                                                                       let _ = "jump"
-                                                                                                       in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                       in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                           )
                                                                           callerInput
                                                                           (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
index 9c3c413b5c4fc3c071337e686febd7303c94eeae..114a5414b50b9b5c68a50d79c9d871ada18c15b1 100644 (file)
                                                                                                       let dupv = \x -> sr ((GHC.Types.:) v x)
                                                                                                       GHC.STRef.writeSTRef reg dupv
                                                                                                       let _ = "jump"
-                                                                                                       in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                       in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                           )
                                                                           callerInput
                                                                           (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
index 78912eed5e8ba1521fa1d81a17030eafe9541a86..8573a2666580220928bbc8a90ff3ed2ce8ac0e69 100644 (file)
                                                                                                   let dupv = \x -> sr ((GHC.Types.:) 'r' x)
                                                                                                   GHC.STRef.writeSTRef reg dupv
                                                                                                   let _ = "jump"
-                                                                                                   in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
+                                                                                                   in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                             else
                                                                               let _ = "checkToken.fail"
                                                                                in let failExp =