Cosmetic file reshuffle

Author: bladyjoker

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

@@ -173,9 +173,9 @@ test-suite tests
     Test.KindCheck.Errors
     Test.LambdaBuffers.Compiler
     Test.LambdaBuffers.Compiler.Coverage
-    Test.LambdaBuffers.Compiler.Gen
-    Test.LambdaBuffers.Compiler.Gen.Mutation
-    Test.LambdaBuffers.Compiler.Gen.Utils
+    Test.LambdaBuffers.Compiler.Mutation
+    Test.LambdaBuffers.Compiler.Utils
+    Test.LambdaBuffers.Compiler.WellFormed
     Test.TypeClassCheck
     Test.Utils.CompilerInput
     Test.Utils.Constructors

lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler.hs

@@ -8,8 +8,8 @@ import LambdaBuffers.Compiler (runCompiler)
 import Proto.Compiler (CompilerOutput)
 import Proto.Compiler_Fields (compilerResult)
 import Test.LambdaBuffers.Compiler.Coverage (coverage)
-import Test.LambdaBuffers.Compiler.Gen (genCompilerInput)
-import Test.LambdaBuffers.Compiler.Gen.Mutation qualified as Mut
+import Test.LambdaBuffers.Compiler.Mutation qualified as Mut
+import Test.LambdaBuffers.Compiler.WellFormed (genCompilerInput)
 import Test.Tasty (TestTree, testGroup)
 import Test.Tasty.HUnit (HasCallStack)
 import Test.Tasty.Hedgehog (testProperty)
@@ -18,27 +18,27 @@ test :: TestTree
 test =
   testGroup
     "Compiler API tests"
-    [ allCorrectCompInpCompile
-    , allCorrectCompInpCompileAfterBenignMut
+    [ allWellFormedCompInpCompile
+    , allWellFormedCompInpCompileAfterBenignMut
     ]
 
 compilationOk :: H.MonadTest m => CompilerOutput -> m ()
 compilationOk compOut = compOut H.=== (defMessage & compilerResult .~ defMessage)
 
-allCorrectCompInpCompile :: HasCallStack => TestTree
-allCorrectCompInpCompile =
+allWellFormedCompInpCompile :: HasCallStack => TestTree
+allWellFormedCompInpCompile =
   testProperty
-    "All correct CompilerInputs must compile"
+    "All well formed CompilerInputs must compile"
     ( H.property $ do
         compInp <- H.forAll genCompilerInput
         coverage compInp
         compilationOk . runCompiler $ compInp
     )
 
-allCorrectCompInpCompileAfterBenignMut :: HasCallStack => TestTree
-allCorrectCompInpCompileAfterBenignMut =
+allWellFormedCompInpCompileAfterBenignMut :: HasCallStack => TestTree
+allWellFormedCompInpCompileAfterBenignMut =
   testProperty
-    "All correct CompilerInputs must compile after a benign mutation"
+    "All well formed CompilerInputs must compile after a benign mutation"
     $ H.property
     $ do
       compInp <- H.forAll genCompilerInput

lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler/Gen/Mutation.hs renamed to lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler/Mutation.hs

@@ -1,4 +1,4 @@
-module Test.LambdaBuffers.Compiler.Gen.Mutation (shuffleModules, shuffleTyDefs, Mutation (..)) where
+module Test.LambdaBuffers.Compiler.Mutation (shuffleModules, shuffleTyDefs, Mutation (..)) where
 
 import Control.Lens ((&), (.~), (^.))
 import Data.List.NonEmpty (nonEmpty)
@@ -9,7 +9,7 @@ import Hedgehog qualified as H
 import Hedgehog.Gen qualified as H
 import Proto.Compiler (CompilerError, CompilerInput, CompilerOutput, CompilerOutput'CompilerOutput (CompilerOutput'CompilerError, CompilerOutput'CompilerResult), CompilerResult)
 import Proto.Compiler_Fields (maybe'compilerOutput, modules, typeDefs)
-import Test.LambdaBuffers.Compiler.Gen.Utils (pick)
+import Test.LambdaBuffers.Compiler.Utils (pick)
 import Test.Tasty (TestName)
 
 data Mutation m = MkMutation

lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler/Gen/Utils.hs renamed to lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler/Utils.hs

@@ -1,4 +1,4 @@
-module Test.LambdaBuffers.Compiler.Gen.Utils (distribute, partition, indexBy, pick) where
+module Test.LambdaBuffers.Compiler.Utils (distribute, partition, indexBy, pick) where
 
 import Control.Monad (foldM)
 import Data.Foldable (Foldable (toList))

lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler/Gen.hs renamed to lambda-buffers-compiler/test/Test/LambdaBuffers/Compiler/WellFormed.hs

@@ -1,4 +1,4 @@
-module Test.LambdaBuffers.Compiler.Gen (genCompilerInput) where
+module Test.LambdaBuffers.Compiler.WellFormed (genCompilerInput) where
 
 import Control.Lens ((&), (.~), (^.))
 import Control.Monad (foldM)
@@ -23,7 +23,7 @@ import Hedgehog.Range qualified as HR
 import Proto.Compiler (ClassName, CompilerInput, ConstrName, Kind, Kind'KindRef (Kind'KIND_REF_TYPE), Module, ModuleName, ModuleNamePart, SourceInfo, Sum, Sum'Constructor, Ty, TyAbs, TyArg, TyBody, TyDef, TyName, VarName)
 import Proto.Compiler_Fields (argKind, argName, column, constrName, constructors, fields, file, foreignTyRef, kindArrow, kindRef, left, localTyRef, moduleName, modules, name, ntuple, parts, posFrom, posTo, right, row, sourceInfo, tyAbs, tyApp, tyArgs, tyBody, tyFunc, tyName, tyRef, tyVar, typeDefs, varName)
 import Proto.Compiler_Fields qualified as P
-import Test.LambdaBuffers.Compiler.Gen.Utils (distribute, indexBy)
+import Test.LambdaBuffers.Compiler.Utils (distribute, indexBy)
 
 -- | Upper bound on various generators
 limit :: Int