recover-rtti 0.5.0 → 0.5.1

raw patch · 31 files changed

+278/−441 lines, 31 filesdep −data-array-bytedep −ghc-internaldep −ghc-primdep ~QuickCheckdep ~basedep ~bytestringPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: data-array-byte, ghc-internal, ghc-prim

Dependency ranges changed: QuickCheck, base, bytestring, containers, ghc-heap, mtl, tasty, tasty-hunit, tasty-quickcheck, unordered-containers, vector

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• recover-rtti.cabal +113/−92
• src/Debug/RecoverRTTI.hs +1/−1
• src/Debug/RecoverRTTI/CheckSame.hs +1/−8
• src/Debug/RecoverRTTI/Classifier.hs +10/−21
• src/Debug/RecoverRTTI/Classify.hs +12/−35
• src/Debug/RecoverRTTI/Constraint.hs +10/−22
• src/Debug/RecoverRTTI/Debugging.hs +0/−2
• src/Debug/RecoverRTTI/FlatClosure.hs +1/−6
• src/Debug/RecoverRTTI/Modules.hs +20/−12
• src/Debug/RecoverRTTI/Nat.hs +0/−7
• src/Debug/RecoverRTTI/Reclassify.hs +0/−9
• src/Debug/RecoverRTTI/Tuple.hs +0/−10
• src/Debug/RecoverRTTI/Tuple/Recursive.hs +0/−6
• src/Debug/RecoverRTTI/Tuple/Size.hs +0/−11
• src/Debug/RecoverRTTI/Util.hs +0/−10
• src/Debug/RecoverRTTI/Wrappers.hs +2/−3
• tests/RecoverRttiTests.hs +3/−3
• tests/Test/RecoverRTTI/Classifier/Arbitrary.hs +14/−25
• tests/Test/RecoverRTTI/Classifier/Equality.hs +2/−3
• tests/Test/RecoverRTTI/Classifier/Size.hs +0/−5
• tests/Test/RecoverRTTI/Classify.hs +27/−30
• tests/Test/RecoverRTTI/ConcreteClassifier.hs +4/−19
• tests/Test/RecoverRTTI/Globals.hs +6/−7
• tests/Test/RecoverRTTI/Prim.hs +25/−32
• tests/Test/RecoverRTTI/QuickCheck/DepGen.hs +1/−13
• tests/Test/RecoverRTTI/QuickCheck/Sized.hs +1/−14
• tests/Test/RecoverRTTI/Sanity.hs +8/−11
• tests/Test/RecoverRTTI/Show.hs +7/−7
• tests/Test/RecoverRTTI/Staged.hs +0/−6
• tests/Test/RecoverRTTI/UserDefined.hs +5/−11

@@ -1,5 +1,10 @@ # Revision history for recover-rtti +## 0.5.1 -- 2025-07-19++* Relax bounds, including support for `QuickCheck-2.16`+* Drop support for `ghc < 9.2`+ ## 0.5.0 -- 2024-06-12  * Support ghc 9.8 and 9.10, including bytestring 0.12

@@ -1,6 +1,6 @@ cabal-version:      2.4 name:               recover-rtti-version:            0.5.0+version:            0.5.1 synopsis:           Recover run-time type information from the GHC heap description:        The main function in this package is 'classify', which looks                     at the GHC heap to recover type information about arbitrary@@ -16,110 +16,131 @@ maintainer:         edsko@well-typed.com copyright:          Juspay Technologies Pvt Ltd, Well-Typed LLP category:           Debugging-extra-source-files:-    README.md-    CHANGELOG.md--Tested-With: GHC ==8.10.7-              || ==9.0.2-              || ==9.2.7-              || ==9.4.5-              || ==9.6.2-              || ==9.8.2-              || ==9.10.1+extra-doc-files:    README.md+                    CHANGELOG.md+tested-with:        GHC==9.2.8+                    GHC==9.4.8+                    GHC==9.6.7+                    GHC==9.8.4+                    GHC==9.10.2+                    GHC==9.12.2  source-repository head   type:     git   location: https://github.com/well-typed/recover-rtti -library-    exposed-modules:  Debug.RecoverRTTI-                      Debug.RecoverRTTI.Classify-                      Debug.RecoverRTTI.ClosureTree+common lang+  build-depends:    base >= 4.16 && < 4.22+  default-language: GHC2021 -    other-modules:    Debug.RecoverRTTI.CheckSame-                      Debug.RecoverRTTI.Classifier-                      Debug.RecoverRTTI.Constraint-                      Debug.RecoverRTTI.Debugging-                      Debug.RecoverRTTI.FlatClosure-                      Debug.RecoverRTTI.Modules-                      Debug.RecoverRTTI.Nat-                      Debug.RecoverRTTI.Reclassify-                      Debug.RecoverRTTI.Tuple-                      Debug.RecoverRTTI.Tuple.Recursive-                      Debug.RecoverRTTI.Tuple.Size-                      Debug.RecoverRTTI.Util-                      Debug.RecoverRTTI.Wrappers+  ghc-options:+      -Wall+      -Wprepositive-qualified-module+      -Wredundant-constraints+      -Wunused-packages -    build-depends:    base       >= 4.13 && < 4.21-                    , aeson      >= 1.4  && < 2.3-                    , bytestring >= 0.10 && < 0.13-                    , containers >= 0.6  && < 0.8-                    , ghc-heap   >= 8.8  && < 9.11-                    , ghc-prim   >= 0.5  && < 0.12-                    , sop-core   >= 0.5  && < 0.6-                    , stm        >= 2.5  && < 2.6-                    , text       >= 1.2  && < 2.2+  default-extensions:+      DataKinds+      DerivingVia+      DerivingStrategies+      LambdaCase+      PatternSynonyms+      QuantifiedConstraints+      RecordWildCards+      TypeFamilies+      UndecidableInstances+      UndecidableSuperClasses+      ViewPatterns -                      -- mtl 2.3 does not have ExceptT?-                    , mtl (>= 2.2 && < 2.3) || (>= 2.3.1 && < 2.4)+library+  import:         lang+  hs-source-dirs: src -                      -- 0.2.12 introduces Data.HashMap.Internal.Array-                    , unordered-containers >= 0.2.12 && < 0.3+  exposed-modules:+      Debug.RecoverRTTI+      Debug.RecoverRTTI.Classify+      Debug.RecoverRTTI.ClosureTree -                      -- The oldest ghc we support is 8.8.-                      -- The dependencies below are the oldest versions of-                      -- these packages that compile with this ghc version.-                    , vector    >= 0.12.1.2 && < 0.14-                    , primitive >= 0.7      && < 0.10+  other-modules:+      Debug.RecoverRTTI.CheckSame+      Debug.RecoverRTTI.Classifier+      Debug.RecoverRTTI.Constraint+      Debug.RecoverRTTI.Debugging+      Debug.RecoverRTTI.FlatClosure+      Debug.RecoverRTTI.Modules+      Debug.RecoverRTTI.Nat+      Debug.RecoverRTTI.Reclassify+      Debug.RecoverRTTI.Tuple+      Debug.RecoverRTTI.Tuple.Recursive+      Debug.RecoverRTTI.Tuple.Size+      Debug.RecoverRTTI.Util+      Debug.RecoverRTTI.Wrappers -    -- later versions of primitive use a compat package for Data.Array.Byte-    if impl(ghc < 9.4)-      build-depends: data-array-byte >= 0.1 && < 0.2+  build-depends:+      -- bundled libraries+    , bytestring >= 0.11 && < 0.13+    , containers >= 0.6  && < 0.8+    , ghc-heap   >= 9.2  && < 9.13+    , mtl        >= 2.2  && < 2.4+    , stm        >= 2.5  && < 2.6+    , text       >= 1.2  && < 2.2 -    if impl(ghc >= 9.10)-      build-depends: ghc-internal+  build-depends:+    , aeson      >= 1.4  && < 2.3+    , sop-core   >= 0.5  && < 0.6+    , vector     >= 0.12 && < 0.14+    , primitive  >= 0.7  && < 0.10 -    hs-source-dirs:   src-    default-language: Haskell2010-    ghc-options:      -Wall-                      -Wredundant-constraints+      -- 0.2.12 introduces Data.HashMap.Internal.Array+    , unordered-containers >= 0.2.12 && < 0.3 +  other-extensions:+      CPP+ test-suite test-recover-rtti-    default-language: Haskell2010-    type:             exitcode-stdio-1.0-    hs-source-dirs:   tests-    main-is:          RecoverRttiTests.hs-    other-modules:    Test.RecoverRTTI.Classifier.Arbitrary-                      Test.RecoverRTTI.Classifier.Equality-                      Test.RecoverRTTI.Classifier.Size-                      Test.RecoverRTTI.Classify-                      Test.RecoverRTTI.ConcreteClassifier-                      Test.RecoverRTTI.Globals-                      Test.RecoverRTTI.Prim-                      Test.RecoverRTTI.QuickCheck.DepGen-                      Test.RecoverRTTI.QuickCheck.Sized-                      Test.RecoverRTTI.Sanity-                      Test.RecoverRTTI.Show-                      Test.RecoverRTTI.Staged-                      Test.RecoverRTTI.UserDefined-    build-depends:    base >= 4.13-                    , recover-rtti+  import: lang+  type:             exitcode-stdio-1.0+  hs-source-dirs:   tests+  main-is:          RecoverRttiTests.hs+  build-depends:    recover-rtti -                    , aeson-                    , bytestring-                    , containers-                    , ghc-heap-                    , ghc-prim-                    , mtl-                    , primitive-                    , QuickCheck-                    , sop-core-                    , stm-                    , tasty-                    , tasty-hunit-                    , tasty-quickcheck-                    , text-                    , unordered-containers-                    , vector-    ghc-options:      -Wall+  other-modules:+      Test.RecoverRTTI.Classifier.Arbitrary+      Test.RecoverRTTI.Classifier.Equality+      Test.RecoverRTTI.Classifier.Size+      Test.RecoverRTTI.Classify+      Test.RecoverRTTI.ConcreteClassifier+      Test.RecoverRTTI.Globals+      Test.RecoverRTTI.Prim+      Test.RecoverRTTI.QuickCheck.DepGen+      Test.RecoverRTTI.QuickCheck.Sized+      Test.RecoverRTTI.Sanity+      Test.RecoverRTTI.Show+      Test.RecoverRTTI.Staged+      Test.RecoverRTTI.UserDefined++  build-depends:+      -- inherited dependencies+    , aeson+    , bytestring+    , containers+    , mtl+    , primitive+    , sop-core+    , stm+    , text+    , unordered-containers+    , vector++  build-depends:+      -- new dependencies+    , QuickCheck       >= 2.15 && < 2.17+    , tasty            >= 1.5  && < 1.6+    , tasty-hunit      >= 0.10 && < 0.11+    , tasty-quickcheck >= 0.11 && < 0.12++  other-extensions:+      CPP+      MagicHash+      UnboxedTuples+      OverloadedStrings

@@ -1,6 +1,6 @@ -- | Recover runtime type information module Debug.RecoverRTTI (-    -- * Take advance of the recovered type information+    -- * Take advantage of the recovered type information     anythingToString     -- * Debugging support     -- ** Tracing

@@ -1,11 +1,4 @@-{-# LANGUAGE CPP                 #-}-{-# LANGUAGE DataKinds           #-}-{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE LambdaCase          #-}-{-# LANGUAGE RankNTypes          #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators       #-}+{-# LANGUAGE CPP #-}  module Debug.RecoverRTTI.CheckSame (     -- * Check if two classifiers are the same

@@ -1,14 +1,4 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE DataKinds             #-}-{-# LANGUAGE FlexibleContexts      #-}-{-# LANGUAGE GADTs                 #-}-{-# LANGUAGE KindSignatures        #-}-{-# LANGUAGE LambdaCase            #-}-{-# LANGUAGE QuantifiedConstraints #-}-{-# LANGUAGE RankNTypes            #-}-{-# LANGUAGE ScopedTypeVariables   #-}-{-# LANGUAGE StandaloneDeriving    #-}-{-# LANGUAGE UndecidableInstances  #-}+{-# LANGUAGE CPP #-}  module Debug.RecoverRTTI.Classifier (     Classifier@@ -24,6 +14,9 @@   ) where  import Data.Aeson (Value)+import Data.ByteString qualified as BS.Strict+import Data.ByteString.Lazy qualified as BS.Lazy+import Data.HashMap.Internal.Array qualified as HashMap (Array) import Data.HashMap.Lazy (HashMap) import Data.HashSet (HashSet) import Data.Int@@ -31,26 +24,22 @@ import Data.IntSet (IntSet) import Data.Kind import Data.Map (Map)+import Data.Primitive.Array qualified as Prim (Array)+import Data.Primitive.ByteArray qualified as Prim (ByteArray) import Data.Ratio import Data.Sequence (Seq) import Data.Set (Set) import Data.SOP import Data.SOP.Dict+import Data.Text qualified as Text.Strict+import Data.Text.Lazy qualified as Text.Lazy import Data.Tree (Tree)+import Data.Vector qualified as Vector.Boxed import Data.Void import Data.Word -import qualified Data.ByteString             as BS.Strict-import qualified Data.ByteString.Lazy        as BS.Lazy-import qualified Data.HashMap.Internal.Array as HashMap (Array)-import qualified Data.Primitive.Array        as Prim (Array)-import qualified Data.Primitive.ByteArray    as Prim (ByteArray)-import qualified Data.Text                   as Text.Strict-import qualified Data.Text.Lazy              as Text.Lazy-import qualified Data.Vector                 as Vector.Boxed- #if !MIN_VERSION_bytestring(0,12,0)-import qualified Data.ByteString.Short as BS.Short+import Data.ByteString.Short qualified as BS.Short #endif  import Debug.RecoverRTTI.Nat

@@ -1,19 +1,4 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE DataKinds             #-}-{-# LANGUAGE FlexibleContexts      #-}-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE GADTs                 #-}-{-# LANGUAGE NamedFieldPuns        #-}-{-# LANGUAGE PatternSynonyms       #-}-{-# LANGUAGE QuantifiedConstraints #-}-{-# LANGUAGE RankNTypes            #-}-{-# LANGUAGE ScopedTypeVariables   #-}-{-# LANGUAGE StandaloneDeriving    #-}-{-# LANGUAGE TupleSections         #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE TypeOperators         #-}-{-# LANGUAGE UndecidableInstances  #-}-{-# LANGUAGE ViewPatterns          #-}+{-# LANGUAGE CPP #-}  {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -38,35 +23,31 @@   ) where  import Control.Monad-import Control.Monad.Except+import Control.Monad.Except (ExceptT(..), runExceptT)+import Control.Monad.Trans (lift)+import Data.Foldable qualified as Foldable+import Data.HashMap.Internal.Array qualified as HashMap (Array)+import Data.HashMap.Internal.Array qualified as HashMap.Array import Data.HashMap.Lazy (HashMap)+import Data.HashMap.Lazy qualified as HashMap import Data.IntMap (IntMap) import Data.Map (Map)+import Data.Map qualified as Map+import Data.Primitive.Array qualified as Prim (Array)+import Data.Primitive.Array qualified as Prim.Array import Data.Sequence (Seq) import Data.Set (Set) import Data.SOP import Data.SOP.Dict import Data.Tree (Tree)+import Data.Tree qualified as Tree+import Data.Vector qualified as Vector.Boxed import Data.Void import GHC.Exts.Heap (Closure) import GHC.Real import System.IO.Unsafe (unsafePerformIO) import Unsafe.Coerce (unsafeCoerce) -#if MIN_VERSION_mtl(2,3,0)-import Control.Monad.Trans-#endif--import qualified Data.Foldable               as Foldable-import qualified Data.HashMap.Internal.Array as HashMap (Array)-import qualified Data.HashMap.Internal.Array as HashMap.Array-import qualified Data.HashMap.Lazy           as HashMap-import qualified Data.Map                    as Map-import qualified Data.Primitive.Array        as Prim.Array-import qualified Data.Primitive.Array        as Prim (Array)-import qualified Data.Tree                   as Tree-import qualified Data.Vector                 as Vector.Boxed- import Debug.RecoverRTTI.Classifier import Debug.RecoverRTTI.Constraint import Debug.RecoverRTTI.FlatClosure@@ -128,11 +109,7 @@       --        -- bytestring-#if MIN_VERSION_bytestring(0,11,0)       (inKnownModule DataByteStringInternal      -> Just "BS")    -> return $ mustBe $ C_Prim C_BS_Strict-#else-      (inKnownModule DataByteStringInternal      -> Just "PS")    -> return $ mustBe $ C_Prim C_BS_Strict-#endif       (inKnownModule DataByteStringLazyInternal  -> Just "Empty") -> return $ mustBe $ C_Prim C_BS_Lazy       (inKnownModule DataByteStringLazyInternal  -> Just "Chunk") -> return $ mustBe $ C_Prim C_BS_Lazy #if !MIN_VERSION_bytestring(0,12,0)

@@ -1,15 +1,4 @@-{-# LANGUAGE ConstraintKinds         #-}-{-# LANGUAGE CPP                     #-}-{-# LANGUAGE DataKinds               #-}-{-# LANGUAGE FlexibleContexts        #-}-{-# LANGUAGE FlexibleInstances       #-}-{-# LANGUAGE GADTs                   #-}-{-# LANGUAGE KindSignatures          #-}-{-# LANGUAGE QuantifiedConstraints   #-}-{-# LANGUAGE RankNTypes              #-}-{-# LANGUAGE ScopedTypeVariables     #-}-{-# LANGUAGE UndecidableInstances    #-}-{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE CPP #-}  -- | Establish that a constraint holds for all classified types module Debug.RecoverRTTI.Constraint (@@ -20,6 +9,9 @@   ) where  import Data.Aeson (Value)+import Data.ByteString qualified as BS.Strict+import Data.ByteString.Lazy qualified as BS.Lazy+import Data.HashMap.Internal.Array qualified as HashMap (Array) import Data.HashMap.Lazy (HashMap) import Data.HashSet (HashSet) import Data.Int@@ -27,26 +19,22 @@ import Data.IntSet (IntSet) import Data.Kind import Data.Map (Map)+import Data.Primitive.Array qualified as Prim (Array)+import Data.Primitive.ByteArray qualified as Prim (ByteArray) import Data.Ratio import Data.Sequence (Seq) import Data.Set (Set) import Data.SOP import Data.SOP.Dict+import Data.Text qualified as Text.Strict+import Data.Text.Lazy qualified as Text.Lazy import Data.Tree (Tree)+import Data.Vector qualified as Vector.Boxed import Data.Void import Data.Word -import qualified Data.ByteString             as BS.Strict-import qualified Data.ByteString.Lazy        as BS.Lazy-import qualified Data.HashMap.Internal.Array as HashMap (Array)-import qualified Data.Primitive.Array        as Prim (Array)-import qualified Data.Primitive.ByteArray    as Prim (ByteArray)-import qualified Data.Text                   as Text.Strict-import qualified Data.Text.Lazy              as Text.Lazy-import qualified Data.Vector                 as Vector.Boxed- #if !MIN_VERSION_bytestring(0,12,0)-import qualified Data.ByteString.Short as BS.Short+import Data.ByteString.Short qualified as BS.Short #endif  import Debug.RecoverRTTI.Classifier

@@ -1,5 +1,3 @@-{-# LANGUAGE ExistentialQuantification #-}- -- | Debugging support module Debug.RecoverRTTI.Debugging (     -- * Tracing

@@ -1,8 +1,3 @@-{-# LANGUAGE BangPatterns    #-}-{-# LANGUAGE LambdaCase      #-}-{-# LANGUAGE NamedFieldPuns  #-}-{-# LANGUAGE RecordWildCards #-}- module Debug.RecoverRTTI.FlatClosure (     FlatClosure(..)   , getBoxedClosureData@@ -14,7 +9,7 @@ import Control.Exception (evaluate) import Control.Monad import GHC.Exts.Heap (Box(..), asBox)-import qualified GHC.Exts.Heap as H+import GHC.Exts.Heap qualified as H  -- | Flattened form of 'Closure' (with indirection nodes removed) --

@@ -1,10 +1,5 @@-{-# LANGUAGE CPP            #-}-{-# LANGUAGE DataKinds      #-}-{-# LANGUAGE GADTs          #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE LambdaCase     #-}-{-# LANGUAGE NamedFieldPuns #-}-{-# LANGUAGE TypeFamilies   #-}+{-# LANGUAGE CPP       #-}+{-# LANGUAGE MagicHash #-}  -- | Modules we recognize types from module Debug.RecoverRTTI.Modules (@@ -272,9 +267,26 @@         SGhcPrim -> \case           GhcTypes -> "GHC.Types" +    -- ghc-prim versions bundled with ghc:+    --+    -- >         base   ghc-prim+    -- > -----------------------+    -- > 9.2.8   4.16   0.8+    -- > 9.4.8   4.17   0.9.1+    -- > 9.6.7   4.18   0.10.0+    -- > 9.8.4   4.19   0.11.0+    -- > 9.10.2  4.20   0.12.0+    -- > 9.12.2  4.21   0.13.0+    --+    -- If we want to use @MIN_VERSION_ghc_prim@, we need to declare a dependency+    -- on @ghc-prim@; since, we don't /actually/ depend on it, however, other+    -- than to check the version, this results in unused package warnings.+    -- We therefore use the version of base as a proxy.+ #if MIN_VERSION_base(4,20,0)           GhcTuple -> "GHC.Tuple"-#elif MIN_VERSION_ghc_prim(0,10,0)+#elif MIN_VERSION_base(4,18,0)+          -- from ghc-prim-0.10           GhcTuple -> "GHC.Tuple.Prim" #else           GhcTuple -> "GHC.Tuple"@@ -311,11 +323,7 @@ #endif          SByteString -> \case-#if MIN_VERSION_bytestring(0,11,4)           DataByteStringInternal      -> "Data.ByteString.Internal.Type"-#else-          DataByteStringInternal      -> "Data.ByteString.Internal"-#endif           DataByteStringLazyInternal  -> "Data.ByteString.Lazy.Internal"           DataByteStringShortInternal -> "Data.ByteString.Short.Internal" 

@@ -1,10 +1,3 @@-{-# LANGUAGE DataKinds            #-}-{-# LANGUAGE GADTs                #-}-{-# LANGUAGE PolyKinds            #-}-{-# LANGUAGE ScopedTypeVariables  #-}-{-# LANGUAGE TypeFamilies         #-}-{-# LANGUAGE TypeOperators        #-}- -- | Inductive type-level natural numbers module Debug.RecoverRTTI.Nat (     -- * Type-level natural numbers

@@ -1,12 +1,3 @@-{-# LANGUAGE DataKinds           #-}-{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE KindSignatures      #-}-{-# LANGUAGE LambdaCase          #-}-{-# LANGUAGE RankNTypes          #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators       #-}- -- | Support for reclassification module Debug.RecoverRTTI.Reclassify (     Reclassified(..)

@@ -1,13 +1,3 @@-{-# LANGUAGE DataKinds            #-}-{-# LANGUAGE FlexibleContexts     #-}-{-# LANGUAGE GADTs                #-}-{-# LANGUAGE PatternSynonyms      #-}-{-# LANGUAGE ScopedTypeVariables  #-}-{-# LANGUAGE TypeApplications     #-}-{-# LANGUAGE TypeOperators        #-}-{-# LANGUAGE UndecidableInstances #-}-{-# LANGUAGE ViewPatterns         #-}- module Debug.RecoverRTTI.Tuple (     -- * Wrapped tuple     WrappedTuple(WrappedTuple, TNil, TCons)

@@ -1,11 +1,5 @@ {-# OPTIONS_GHC -Wno-overlapping-patterns -Wno-incomplete-patterns -Wno-incomplete-uni-patterns -fno-opt-coercion #-} -{-# LANGUAGE DataKinds               #-}-{-# LANGUAGE FlexibleContexts        #-}-{-# LANGUAGE ScopedTypeVariables     #-}-{-# LANGUAGE TypeFamilies            #-}-{-# LANGUAGE TypeOperators           #-}- -- | Provide a recursive views on tuples -- -- NOTE: We disable the GHC pattern match checker (this makes compilation /much/

@@ -1,14 +1,3 @@-{-# LANGUAGE DataKinds           #-}-{-# LANGUAGE EmptyCase           #-}-{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE FlexibleInstances   #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE KindSignatures      #-}-{-# LANGUAGE LambdaCase          #-}-{-# LANGUAGE RankNTypes          #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeApplications    #-}- {-# OPTIONS_GHC -Wno-overlapping-patterns -Wno-incomplete-patterns -Wno-incomplete-uni-patterns -fno-opt-coercion #-}  -- | Valid tuple size

@@ -1,13 +1,3 @@-{-# LANGUAGE ConstraintKinds     #-}-{-# LANGUAGE DataKinds           #-}-{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE LambdaCase          #-}-{-# LANGUAGE PolyKinds           #-}-{-# LANGUAGE RankNTypes          #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators       #-}- module Debug.RecoverRTTI.Util (     -- * Existentials     Some(..)

@@ -31,11 +31,10 @@  import Control.Concurrent.MVar (MVar) import Control.Concurrent.STM (TVar)+import Data.Primitive.Array qualified as Prim (MutableArray)+import Data.Primitive.ByteArray qualified as Prim (MutableByteArray) import Data.STRef (STRef) import GHC.Exts--import qualified Data.Primitive.Array     as Prim (MutableArray)-import qualified Data.Primitive.ByteArray as Prim (MutableByteArray)  {-------------------------------------------------------------------------------   User-defined types

@@ -2,9 +2,9 @@  import Test.Tasty -import qualified Test.RecoverRTTI.Sanity-import qualified Test.RecoverRTTI.Classify-import qualified Test.RecoverRTTI.Show+import Test.RecoverRTTI.Sanity   qualified+import Test.RecoverRTTI.Classify qualified+import Test.RecoverRTTI.Show     qualified  main :: IO () main = defaultMain tests

@@ -1,50 +1,39 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE DataKinds             #-}-{-# LANGUAGE FlexibleContexts      #-}-{-# LANGUAGE GADTs                 #-}-{-# LANGUAGE KindSignatures        #-}-{-# LANGUAGE LambdaCase            #-}-{-# LANGUAGE QuantifiedConstraints #-}-{-# LANGUAGE RankNTypes            #-}-{-# LANGUAGE ScopedTypeVariables   #-}-{-# LANGUAGE TypeOperators         #-}+{-# LANGUAGE CPP #-}  module Test.RecoverRTTI.Classifier.Arbitrary (arbitraryClassifier_) where  import Data.Bifunctor+import Data.HashMap.Internal.Array qualified as HashMap.Array+import Data.HashMap.Lazy qualified as HashMap+import Data.HashSet qualified as HashSet+import Data.IntMap qualified as IntMap import Data.Kind+import Data.Map qualified as Map+import Data.Sequence qualified as Seq+import Data.Set qualified as Set import Data.SOP import Data.Tree (Tree)+import Data.Tree qualified as Tree+import Data.Vector qualified as Vector.Boxed import Data.Void import GHC.Real (Ratio((:%)))  #if MIN_VERSION_base(4,17,0)-import qualified GHC.IsList as IsList+import GHC.IsList qualified as IsList #else-import qualified GHC.Exts as IsList (fromList)+import GHC.Exts qualified as IsList (fromList) #endif -import qualified Data.HashMap.Internal.Array as HashMap.Array-import qualified Data.HashMap.Lazy           as HashMap-import qualified Data.HashSet                as HashSet-import qualified Data.IntMap                 as IntMap-import qualified Data.Map                    as Map-import qualified Data.Sequence               as Seq-import qualified Data.Set                    as Set-import qualified Data.Tree                   as Tree-import qualified Data.Vector                 as Vector.Boxed- import Debug.RecoverRTTI import Debug.RecoverRTTI.Classify -import Test.QuickCheck+import Test.QuickCheck (Gen)  import Test.RecoverRTTI.Classifier.Equality () import Test.RecoverRTTI.Prim import Test.RecoverRTTI.QuickCheck.DepGen import Test.RecoverRTTI.QuickCheck.Sized (SizedGen)--import qualified Test.RecoverRTTI.QuickCheck.Sized as SG+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG  {-------------------------------------------------------------------------------   Generate arbitiary classifiers

@@ -4,9 +4,8 @@ module Test.RecoverRTTI.Classifier.Equality () where  import Data.Function (on)--import qualified Data.HashMap.Internal.Array as HashMap (Array)-import qualified Data.HashMap.Internal.Array as HashMap.Array+import Data.HashMap.Internal.Array qualified as HashMap (Array)+import Data.HashMap.Internal.Array qualified as HashMap.Array  import Debug.RecoverRTTI 

@@ -1,8 +1,3 @@-{-# LANGUAGE FlexibleContexts    #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE RankNTypes          #-}-{-# LANGUAGE ScopedTypeVariables #-}- module Test.RecoverRTTI.Classifier.Size (classifierSize_) where  import Data.SOP

@@ -1,41 +1,38 @@-{-# LANGUAGE CPP                 #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE LambdaCase          #-}-{-# LANGUAGE OverloadedStrings   #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeApplications    #-}+{-# LANGUAGE CPP               #-}+{-# LANGUAGE OverloadedStrings #-}  -- | Verify we infer the right classifier module Test.RecoverRTTI.Classify (tests) where  import Control.Monad.Except+import Data.Aeson qualified as Aeson+import Data.HashMap.Internal.Array qualified as HashMap.Array+import Data.HashMap.Lazy qualified as HashMap+import Data.HashSet qualified as HashSet+import Data.IntMap qualified as IntMap+import Data.IntSet qualified as IntSet+import Data.Map qualified as Map import Data.Ratio+import Data.Sequence qualified as Seq+import Data.Set qualified as Set import Data.SOP+import Data.Tree qualified as Tree import Data.Type.Equality+import Data.Vector qualified as Vector.Boxed+import Data.Vector.Primitive qualified as Vector.Primitive+import Data.Vector.Storable qualified as Vector.Storable import Unsafe.Coerce (unsafeCoerce)  #if MIN_VERSION_base(4,17,0)-import qualified GHC.IsList as IsList+import GHC.IsList qualified as IsList #else-import qualified GHC.Exts as IsList (fromList)+import GHC.Exts qualified as IsList (fromList) #endif -import qualified Data.Aeson                  as Aeson-import qualified Data.HashMap.Internal.Array as HashMap.Array-import qualified Data.HashMap.Lazy           as HashMap-import qualified Data.HashSet                as HashSet-import qualified Data.IntMap                 as IntMap-import qualified Data.IntSet                 as IntSet-import qualified Data.Map                    as Map-import qualified Data.Sequence               as Seq-import qualified Data.Set                    as Set-import qualified Data.Tree                   as Tree-import qualified Data.Vector                 as Vector.Boxed-import qualified Data.Vector.Storable        as Vector.Storable-import qualified Data.Vector.Primitive       as Vector.Primitive- import Test.Tasty-import Test.Tasty.QuickCheck hiding (classify, NonEmpty)+import Test.Tasty.QuickCheck (testProperty)+import Test.QuickCheck (Property)+import Test.QuickCheck qualified as QC  import Debug.RecoverRTTI import Debug.RecoverRTTI.Classify@@ -57,7 +54,7 @@ -- but their on-heap representation may be different, and this may effect the -- RTTI recovery. prop_constants :: Property-prop_constants = withMaxSuccess 1 $ conjoin [+prop_constants = QC.withMaxSuccess 1 $ QC.conjoin [       -- Primitive types        compareClassifier $ Value (C_Prim C_Bool)     True@@ -330,15 +327,15 @@ -- The tests in this module differ only in how the produce the 'Value's. compareClassifier :: Value a -> Property compareClassifier = \(Value cc x) ->-      counterexample ("Generated classifier: " ++ show cc)+      QC.counterexample ("Generated classifier: " ++ show cc)     $ case runExcept $ classifyConcrete x of         Left err  ->-            counterexample ("Failed to reclassify. Error: " ++ err)-          $ property False+            QC.counterexample ("Failed to reclassify. Error: " ++ err)+          $ QC.property False         Right (Reclassified cc' _pf) ->           case sameConcrete cc cc' of             Nothing ->-                counterexample ("Inferred different classifier: " ++ show cc')-              $ property False+                QC.counterexample ("Inferred different classifier: " ++ show cc')+              $ QC.property False             Just Refl ->-              property True+              QC.property True

@@ -1,18 +1,3 @@-{-# LANGUAGE ConstraintKinds         #-}-{-# LANGUAGE DataKinds               #-}-{-# LANGUAGE FlexibleContexts        #-}-{-# LANGUAGE FlexibleInstances       #-}-{-# LANGUAGE GADTs                   #-}-{-# LANGUAGE KindSignatures          #-}-{-# LANGUAGE LambdaCase              #-}-{-# LANGUAGE QuantifiedConstraints   #-}-{-# LANGUAGE RankNTypes              #-}-{-# LANGUAGE ScopedTypeVariables     #-}-{-# LANGUAGE StandaloneDeriving      #-}-{-# LANGUAGE TypeOperators           #-}-{-# LANGUAGE UndecidableInstances    #-}-{-# LANGUAGE UndecidableSuperClasses #-}- module Test.RecoverRTTI.ConcreteClassifier (     -- * Concrete classifier     ConcreteClassifier@@ -43,17 +28,17 @@ import Debug.RecoverRTTI import Debug.RecoverRTTI.Classify -import Test.QuickCheck+import Test.QuickCheck (Arbitrary(..), Gen)+import Test.QuickCheck qualified as QC  import Test.RecoverRTTI.Classifier.Arbitrary import Test.RecoverRTTI.Classifier.Equality () import Test.RecoverRTTI.Classifier.Size import Test.RecoverRTTI.QuickCheck.DepGen import Test.RecoverRTTI.QuickCheck.Sized (SizedGen)+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG import Test.RecoverRTTI.UserDefined -import qualified Test.RecoverRTTI.QuickCheck.Sized as SG- {-------------------------------------------------------------------------------   Concrete classifier @@ -207,7 +192,7 @@ arbitraryUser = SG.leafOrStep leaf compound   where     leaf :: Gen (Some (DepGen ClassifyUser))-    leaf = oneof [+    leaf = QC.oneof [           -- SimpleType           pure . Some $ arbitraryDepGen C_Simple 

@@ -19,20 +19,19 @@ import Control.Concurrent.STM (newTVarIO) import Control.Monad.ST.Unsafe (unsafeSTToIO) import Data.IORef (newIORef)+import Data.Primitive.Array qualified as Prim.Array+import Data.Primitive.ByteArray qualified as Prim.ByteArray import Data.STRef (newSTRef)+import Data.Vector.Primitive qualified as Vector.Primitive+import Data.Vector.Storable qualified as Vector.Storable import System.IO.Unsafe (unsafePerformIO) import Unsafe.Coerce (unsafeCoerce)  #if MIN_VERSION_base(4,17,0)-import qualified GHC.IsList as IsList+import GHC.IsList qualified as IsList #else-import qualified GHC.Exts as IsList (fromList)+import GHC.Exts qualified as IsList (fromList) #endif--import qualified Data.Primitive.Array     as Prim.Array-import qualified Data.Primitive.ByteArray as Prim.ByteArray-import qualified Data.Vector.Primitive    as Vector.Primitive-import qualified Data.Vector.Storable     as Vector.Storable  import Debug.RecoverRTTI 

@@ -1,11 +1,4 @@-{-# LANGUAGE CPP                        #-}-{-# LANGUAGE DerivingStrategies         #-}-{-# LANGUAGE FlexibleInstances          #-}-{-# LANGUAGE GADTs                      #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE LambdaCase                 #-}-{-# LANGUAGE OverloadedStrings          #-}-{-# LANGUAGE StandaloneDeriving         #-}+{-# LANGUAGE CPP #-}  module Test.RecoverRTTI.Prim (     -- * Equality@@ -17,37 +10,37 @@   ) where  import Control.Monad (replicateM)+import Data.Aeson qualified as Aeson+import Data.ByteString qualified as BS.Strict+import Data.ByteString.Lazy qualified as BS.Lazy import Data.Int import Data.IntSet (IntSet)+import Data.Primitive.ByteArray qualified as Prim (ByteArray) import Data.SOP (Compose) import Data.SOP.Dict import Data.String (fromString)+import Data.Text qualified as Text.Strict+import Data.Text.Lazy qualified as Text.Lazy+import Data.Vector qualified as Vector.Boxed+import Data.Vector.Primitive qualified as Vector.Primitive+import Data.Vector.Storable qualified as Vector.Storable import Data.Word import Unsafe.Coerce (unsafeCoerce)  #if MIN_VERSION_base(4,17,0)-import qualified GHC.IsList as IsList+import GHC.IsList qualified as IsList #else-import qualified GHC.Exts as IsList (fromList)+import GHC.Exts qualified as IsList (fromList) #endif -import qualified Data.Aeson               as Aeson-import qualified Data.ByteString          as BS.Strict-import qualified Data.ByteString.Lazy     as BS.Lazy-import qualified Data.Primitive.ByteArray as Prim (ByteArray)-import qualified Data.Text                as Text.Strict-import qualified Data.Text.Lazy           as Text.Lazy-import qualified Data.Vector              as Vector.Boxed-import qualified Data.Vector.Primitive    as Vector.Primitive-import qualified Data.Vector.Storable     as Vector.Storable- #if !MIN_VERSION_bytestring(0,12,0)-import qualified Data.ByteString.Short as BS.Short+import Data.ByteString.Short qualified as BS.Short #endif  import Debug.RecoverRTTI -import Test.QuickCheck+import Test.QuickCheck (Arbitrary(..), Gen)+import Test.QuickCheck qualified as QC  import Test.RecoverRTTI.Classifier.Equality () import Test.RecoverRTTI.Globals@@ -67,7 +60,7 @@ primSatisfiesArbitrary = primSatisfies  arbitraryPrimClassifier :: Gen (Some PrimClassifier)-arbitraryPrimClassifier = elements [+arbitraryPrimClassifier = QC.elements [     -- Primitive types        Some C_Bool@@ -233,11 +226,11 @@ -- but it generates values that are too big, which cause the size sanity check -- on the generator 'prop_showGenerated' to start to fail. instance Arbitrary (Wrap Aeson.Value) where-  arbitrary = choose (0, 10) >>= fmap Wrap . go+  arbitrary = QC.choose (0, 10) >>= fmap Wrap . go     where       go :: Int -> Gen Aeson.Value-      go 0  = oneof nonRecursive-      go sz = oneof (nonRecursive ++ recursive sz)+      go 0  = QC.oneof nonRecursive+      go sz = QC.oneof (nonRecursive ++ recursive sz)        nonRecursive :: [Gen Aeson.Value]       nonRecursive = [@@ -249,9 +242,9 @@        recursive :: Int -> [Gen Aeson.Value]       recursive sz = [-            do n <- choose (0, 5)+            do n <- QC.choose (0, 5)                Aeson.Array . Vector.Boxed.fromList <$> replicateM n (go (sz `div` n))-          , do n <- choose (0, 5)+          , do n <- QC.choose (0, 5)                Aeson.object <$> replicateM n (                        (Aeson..=)                    <$> (fromString <$> fieldName)@@ -261,12 +254,12 @@        -- We're not interested in testing crazy values       fieldName :: Gen String-      fieldName = elements ["a", "b", "c"]+      fieldName = QC.elements ["a", "b", "c"]  -- | Rather than trying to be clever here, we just generate a handful of -- examples in different categories. instance Arbitrary (Wrap SomeFun) where-  arbitrary = fmap Wrap $ elements [+  arbitrary = fmap Wrap $ QC.elements [         -- Parametrically polymorphic function         fun (id    :: Int -> Int)       , fun (const :: Int -> Bool -> Int)@@ -282,7 +275,7 @@       fun = unsafeCoerce  instance Arbitrary (Wrap SomeStorableVector) where-  arbitrary = fmap Wrap $ elements [+  arbitrary = fmap Wrap $ QC.elements [         some $ Vector.Storable.fromList ([1, 2, 3] :: [Int])       , some $ Vector.Storable.fromList ("abc"     :: String)       ]@@ -291,7 +284,7 @@       some = unsafeCoerce  instance Arbitrary (Wrap SomePrimitiveVector) where-  arbitrary = fmap Wrap $ elements [+  arbitrary = fmap Wrap $ QC.elements [         some $ Vector.Primitive.fromList ([1, 2, 3] :: [Int])       , some $ Vector.Primitive.fromList ("abc"     :: String)       ]

@@ -1,14 +1,3 @@-{-# LANGUAGE DataKinds             #-}-{-# LANGUAGE FlexibleContexts      #-}-{-# LANGUAGE GADTs                 #-}-{-# LANGUAGE KindSignatures        #-}-{-# LANGUAGE NamedFieldPuns        #-}-{-# LANGUAGE QuantifiedConstraints #-}-{-# LANGUAGE RankNTypes            #-}-{-# LANGUAGE ScopedTypeVariables   #-}-{-# LANGUAGE TypeApplications      #-}-{-# LANGUAGE UndecidableInstances  #-}- module Test.RecoverRTTI.QuickCheck.DepGen (     -- * Dependent generator     DepGen(..)@@ -41,8 +30,7 @@  import Test.RecoverRTTI.Prim import Test.RecoverRTTI.QuickCheck.Sized (SizedGen)--import qualified Test.RecoverRTTI.QuickCheck.Sized as SG+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG  {-------------------------------------------------------------------------------   Dependent generator

@@ -1,15 +1,3 @@-{-# LANGUAGE DataKinds                  #-}-{-# LANGUAGE DeriveFunctor              #-}-{-# LANGUAGE DerivingStrategies         #-}-{-# LANGUAGE FlexibleContexts           #-}-{-# LANGUAGE GADTs                      #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE KindSignatures             #-}-{-# LANGUAGE RankNTypes                 #-}-{-# LANGUAGE ScopedTypeVariables        #-}-{-# LANGUAGE TypeApplications           #-}-{-# LANGUAGE TypeOperators              #-}- -- | Sized generators -- -- Intended for qualified import@@ -48,8 +36,7 @@ import Debug.RecoverRTTI  import Test.QuickCheck (Arbitrary, Gen)--import qualified Test.QuickCheck as QC+import Test.QuickCheck qualified as QC  {-------------------------------------------------------------------------------   Sized generators

@@ -1,7 +1,3 @@-{-# LANGUAGE DerivingVia        #-}-{-# LANGUAGE FlexibleInstances  #-}-{-# LANGUAGE StandaloneDeriving #-}- module Test.RecoverRTTI.Sanity (tests) where  import Data.SOP.BasicFunctors@@ -12,12 +8,13 @@  import Test.Tasty import Test.Tasty.HUnit-import Test.Tasty.QuickCheck+import Test.Tasty.QuickCheck (testProperty)+import Test.QuickCheck (Property)+import Test.QuickCheck qualified as QC  import Test.RecoverRTTI.ConcreteClassifier import Test.RecoverRTTI.QuickCheck.DepGen--import qualified Test.RecoverRTTI.QuickCheck.Sized as SG+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG  tests :: TestTree tests = testGroup "Test.RecoverRTTI.Sanity" [@@ -28,10 +25,10 @@  prop_typeSize :: Property prop_typeSize =-    forAll (Blind <$> SG.run 10 arbitraryConcrete) $-      \(Blind (Some (DepGen classifier _))) ->-          counterexample ("classifier: " ++ show classifier)-        $ counterexample ("size: " ++ show (sizeConcrete classifier))+    QC.forAll (QC.Blind <$> SG.run 10 arbitraryConcrete) $+      \(QC.Blind (Some (DepGen classifier _))) ->+          QC.counterexample ("classifier: " ++ show classifier)+        $ QC.counterexample ("size: " ++ show (sizeConcrete classifier))         $ sizeConcrete classifier <= 100  {-------------------------------------------------------------------------------

@@ -1,10 +1,10 @@-{-# LANGUAGE NumericUnderscores #-}- -- | Verify that 'anythingToString' produces same result as 'show' module Test.RecoverRTTI.Show (tests) where  import Test.Tasty-import Test.Tasty.QuickCheck hiding (classify)+import Test.Tasty.QuickCheck (testProperty)+import Test.QuickCheck (Property, (===))+import Test.QuickCheck qualified as QC  import Debug.RecoverRTTI @@ -21,12 +21,12 @@ -- This is a sanity check on the generator. prop_showGenerated :: Some Value -> Property prop_showGenerated (Some (Value _cc x)) =-     counterexample ("length: " ++ show (length (show x)))-   $ property (length (show x) < 1_000_000)+     QC.counterexample ("length: " ++ show (length (show x)))+   $ QC.property (length (show x) < 1_000_000)  -- | Compare " normal " 'show' against the " recovered " 'show' prop_anythingToString :: Some Value -> Property prop_anythingToString (Some (Value _cc x)) =-      counterexample ("inferred: " ++ show (classify x))-    $ within 2_000_000+      QC.counterexample ("inferred: " ++ show (classify x))+    $ QC.within 2_000_000     $ show x === anythingToString x

@@ -1,9 +1,3 @@-{-# LANGUAGE DataKinds           #-}-{-# LANGUAGE GADTs               #-}-{-# LANGUAGE RankNTypes          #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeApplications    #-}- -- | Staged inference -- -- Suppose we have a user-defined type such as

@@ -1,12 +1,5 @@-{-# LANGUAGE BangPatterns      #-}-{-# LANGUAGE DataKinds         #-}-{-# LANGUAGE DeriveGeneric     #-}-{-# LANGUAGE DeriveTraversable #-}-{-# LANGUAGE MagicHash         #-}-{-# LANGUAGE PolyKinds         #-}-{-# LANGUAGE TypeFamilies      #-}-{-# LANGUAGE TypeOperators     #-}-{-# LANGUAGE UnboxedTuples     #-}+{-# LANGUAGE MagicHash     #-}+{-# LANGUAGE UnboxedTuples #-}  -- | Just some examples of user-defined types module Test.RecoverRTTI.UserDefined (@@ -20,9 +13,10 @@   ) where  import Data.Proxy+import GHC.Exts (RealWorld, MutableArray#, newArray#) import GHC.Generics-import GHC.IO-import GHC.Prim+import GHC.IO (IO(..))+import System.IO.Unsafe (unsafePerformIO)  import Test.QuickCheck