update: clean-up

Author: cstml

lambda-buffers-compiler/lambda-buffers-compiler.cabal

@@ -156,10 +156,9 @@ test-suite tests
 
   other-modules:
     Test.KindCheck
-    Test.Samples
     Test.Samples.Proto.CompilerInput
-    Test.Samples.Proto.Helpers
     Test.Samples.Proto.Module
     Test.Samples.Proto.SourceInfo
     Test.Samples.Proto.TyDef
+    Test.Samples.Proto.Utils
     Test.TypeClassCheck

lambda-buffers-compiler/src/LambdaBuffers/Compiler/KindCheck/Type.hs

@@ -8,7 +8,7 @@ module LambdaBuffers.Compiler.KindCheck.Type (
 
 import LambdaBuffers.Compiler.KindCheck.Variable (Variable (LocalRef))
 import Prettyprinter (Doc, Pretty (pretty), parens, (<+>))
-import Test.QuickCheck (Arbitrary, arbitrary, oneof, sized)
+import Test.QuickCheck (Arbitrary, Gen, arbitrary, oneof, sized)
 
 data Type
   = Var Variable
@@ -37,6 +37,7 @@ instance Pretty Type where
 instance Arbitrary Type where
   arbitrary = sized f
     where
+      f :: Integral a => a -> Gen Type
       f n
         | n <= 0 = Var <$> arbitrary
         | otherwise =

lambda-buffers-compiler/src/LambdaBuffers/Compiler/KindCheck/Variable.hs

@@ -1,15 +1,19 @@
 module LambdaBuffers.Compiler.KindCheck.Variable (Variable (LocalRef, ForeignRef), Atom) where
 
 import Data.Text (Text)
-import Orphan.Text
+import GHC.Generics (Generic)
+import Orphan.Text ()
 import Prettyprinter (Pretty (pretty), concatWith)
+import Test.QuickCheck (Arbitrary)
+import Test.QuickCheck.Arbitrary.Generic (GenericArbitrary (GenericArbitrary))
 
 type Atom = Text
 
 data Variable
   = LocalRef Text
   | ForeignRef [Text] Text
-  deriving stock (Eq, Ord, Show)
+  deriving stock (Eq, Ord, Show, Generic)
+  deriving (Arbitrary) via GenericArbitrary Variable
 
 instance Pretty Variable where
   pretty = \case

lambda-buffers-compiler/src/LambdaBuffers/Compiler/ProtoCompat/Types.hs

@@ -46,12 +46,11 @@ module LambdaBuffers.Compiler.ProtoCompat.Types (
 
 import Control.Exception (Exception)
 import Data.List.NonEmpty (NonEmpty ((:|)), (<|))
-import Data.Map qualified as M
 import Data.Text (Text)
 import GHC.Generics (Generic)
-import LambdaBuffers.Compiler.KindCheck.Variable as VARS (Atom, Var, Variable)
-import Test.QuickCheck (Arbitrary (arbitrary), Gen, NonEmptyList (getNonEmpty), oneof, resize, sized)
-import Test.QuickCheck.Arbitrary.Generic
+import LambdaBuffers.Compiler.KindCheck.Variable as VARS (Atom, Variable)
+import Test.QuickCheck (Gen, oneof, resize, sized)
+import Test.QuickCheck.Arbitrary.Generic (Arbitrary (arbitrary), GenericArbitrary (GenericArbitrary))
 
 data SourceInfo = SourceInfo {file :: Text, posFrom :: SourcePosition, posTo :: SourcePosition}
   deriving stock (Show, Eq, Ord, Generic)
@@ -128,6 +127,7 @@ data Ty = TyVarI TyVar | TyAppI TyApp | TyRefI TyRef
 instance Arbitrary Ty where
   arbitrary = sized fn
     where
+      fn :: (Num a, Ord a) => a -> Gen Ty
       fn n
         | n <= 0 = TyRefI <$> arbitrary
         | otherwise =
@@ -276,7 +276,6 @@ instance Arbitrary CompilerInput where
     where
       fn n = CompilerInput <$> resize n arbitrary
 
-newtype CompilerOutput = CompilerOutput {typeDefs :: M.Map Var Kind}
 data KindCheckError
   = -- | The following term is unbound in the following type definition.
     UnboundTermError TyName VarName
@@ -287,22 +286,23 @@ data KindCheckError
   | -- | The following type has the wrong.
     InconsistentTypeError TyName Kind Kind
   deriving stock (Show, Eq, Ord, Generic)
+  deriving (Arbitrary) via GenericArbitrary KindCheckError
 instance Exception KindCheckError
 
 data CompilerError
   = CompKindCheckError KindCheckError
   | InternalError Text
   deriving stock (Show, Eq, Ord, Generic)
-  deriving (Arbitrary) via GenericArbitrary CompilerOutput
+  deriving (Arbitrary) via GenericArbitrary CompilerError
 
 data CompilerResult = CompilerResult
   deriving stock (Show, Eq, Ord, Generic)
-  deriving (Arbitrary) via GenericArbitrary CompilerFailure
+  deriving (Arbitrary) via GenericArbitrary CompilerResult
 
 type CompilerOutput = Either CompilerError CompilerResult
 
-nonEmptyArbList :: forall a. Arbitrary a => Gen [a]
-nonEmptyArbList = getNonEmpty <$> arbitrary @(NonEmptyList a)
+-- nonEmptyArbList :: forall a. Arbitrary a => Gen [a]
+-- nonEmptyArbList = getNonEmpty <$> arbitrary @(NonEmptyList a)
 
 -- Orphan Instances
 instance Arbitrary a => Arbitrary (NonEmpty a) where

lambda-buffers-compiler/src/Orphan/Text.hs

@@ -1,7 +1,17 @@
-module Orphan.Text where
+{-# OPTIONS_GHC -Wno-orphans #-}
 
-import Data.Text
-import Test.QuickCheck (Arbitrary (arbitrary), Gen, oneof, sized)
+module Orphan.Text () where
+
+import Data.Text (Text, pack)
+import Test.QuickCheck (Arbitrary (arbitrary), Gen, sized)
 
 instance Arbitrary Text where
-  arbitrary = pack <$> arbitrary
+  arbitrary = sized f
+    where
+      f :: (Ord a, Num a) => a -> Gen Text
+      f n
+        | n <= 0 = pure $ pack []
+        | otherwise = do
+            c <- arbitrary
+            cs <- f (n - 1)
+            pure $ pack [c] <> cs

lambda-buffers-compiler/test/Test/KindCheck.hs

@@ -78,6 +78,7 @@ kcTestOrdering =
       shuffledMods <- shuffle mods
       pure (P.CompilerInput mods, P.CompilerInput shuffledMods)
 
+    eitherFailOrPass :: forall {a} {c}. Either a c -> Either () ()
     eitherFailOrPass = bimap (const ()) (const ())
 
 --------------------------------------------------------------------------------

lambda-buffers-compiler/test/Test/Samples.hs

@@ -1,7 +1,7 @@
 module Test.Samples.Proto.TyDef (tyDef'maybe, tyDef'incoherent) where
 
 import LambdaBuffers.Compiler.ProtoCompat qualified as P
-import Test.Samples.Proto.Helpers (
+import Test.Samples.Proto.Utils (
   _TupleI,
   _TyAbs,
   _TyDef,

lambda-buffers-compiler/test/Test/Samples/Proto/TyDef.hs

@@ -1,4 +1,4 @@
-module Test.Samples.Proto.Helpers (
+module Test.Samples.Proto.Utils (
   _tyName,
   _varName,
   _tyVar,