new: test 1 undefined variable

Author: cstml

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

@@ -162,6 +162,7 @@ test-suite tests
 
   other-modules:
     Test.KindCheck
+    Test.KindCheck.Errors
     Test.LambdaBuffers.Compiler
     Test.LambdaBuffers.Compiler.Gen
     Test.TypeClassCheck

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

@@ -11,11 +11,10 @@ import LambdaBuffers.Compiler.KindCheck.Variable (
   Variable (LocalRef),
  )
 
+import Test.KindCheck.Errors (testGKindCheckErrors)
 import Test.QuickCheck (
-  Arbitrary (arbitrary, shrink),
-  Property,
+  Arbitrary (arbitrary),
   forAll,
-  forAllShrink,
   (===),
  )
 import Test.Tasty (TestTree, testGroup)
@@ -31,7 +30,7 @@ import Test.Utils.Constructors (_CompilerInput)
 -- Top Level tests
 
 test :: TestTree
-test = testGroup "Compiler tests" [testCheck, testFolds, testRefl]
+test = testGroup "Compiler tests" [testCheck, testFolds, testGKindCheckErrors]
 
 --------------------------------------------------------------------------------
 -- Module tests
@@ -139,10 +138,3 @@ testSumFold3 =
 -- | TyDef to Kind Canonical representation - sums not folded - therefore we get constructor granularity. Might use in a different implementation for more granular errors.
 lVar :: Text -> Type
 lVar = Var . LocalRef
-
--- Property Tests
-testRefl :: TestTree
-testRefl = testProperty "Refl" reflTerm
-  where
-    reflTerm :: Property
-    reflTerm = forAllShrink (arbitrary @Int) shrink (\a -> a == a)

lambda-buffers-compiler/test/Test/Utils/CompilerInput.hs

@@ -1,8 +1,8 @@
-module Test.Utils.CompilerInput (compilerInput'incoherent, compilerInput'maybe) where
+module Test.Utils.CompilerInput (compilerInput'incoherent, compilerInput'maybe, compilerInput'undefinedVariable) where
 
 import LambdaBuffers.Compiler.ProtoCompat qualified as P
 import Test.Utils.Constructors (_CompilerInput)
-import Test.Utils.Module (module'incoherent, module'maybe)
+import Test.Utils.Module (module'incoherent, module'maybe, module'undefinedVar)
 
 -- | Compiler Input containing 1 module with 1 definition - Maybe.
 compilerInput'maybe :: P.CompilerInput
@@ -11,3 +11,7 @@ compilerInput'maybe = _CompilerInput [module'maybe]
 -- | Contains 2 definitions - 1 wrong one.
 compilerInput'incoherent :: P.CompilerInput
 compilerInput'incoherent = _CompilerInput [module'maybe, module'incoherent]
+
+-- | Contains 1 undefined variable.
+compilerInput'undefinedVariable :: P.CompilerInput
+compilerInput'undefinedVariable = _CompilerInput [module'undefinedVar]

lambda-buffers-compiler/test/Test/Utils/Constructors.hs

@@ -1,7 +1,8 @@
 module Test.Utils.Constructors (
-  _tyName,
-  _varName,
-  _tyVar,
+  _TyName,
+  _VarName,
+  _TyVar,
+  _TyVar',
   _TyVarI,
   _TupleI,
   _Constructor,
@@ -16,12 +17,15 @@ module Test.Utils.Constructors (
   _CompilerInput,
   _ModuleName,
   _ModuleNamePart,
+  _TyVarI',
+  _SourceInfo,
 ) where
 
 import Control.Lens ((^.))
 import Data.Map qualified as Map
 import Data.Text (Text)
 import LambdaBuffers.Compiler.ProtoCompat qualified as P
+import LambdaBuffers.Compiler.ProtoCompat.Types (SourceInfo)
 
 _CompilerInput :: [P.Module] -> P.CompilerInput
 _CompilerInput ms =
@@ -50,17 +54,31 @@ _ModuleName ps =
 _ModuleNamePart :: Text -> P.ModuleNamePart
 _ModuleNamePart n = P.ModuleNamePart n P.defSourceInfo
 
-_tyName :: Text -> P.TyName
-_tyName x = P.TyName x P.defSourceInfo
+_TyName :: Text -> P.TyName
+_TyName x = P.TyName x P.defSourceInfo
 
-_varName :: Text -> P.VarName
-_varName x = P.VarName {P.name = x, P.sourceInfo = P.defSourceInfo}
+_VarName :: Text -> P.VarName
+_VarName x = P.VarName {P.name = x, P.sourceInfo = P.defSourceInfo}
 
-_tyVar :: Text -> P.TyVar
-_tyVar x = P.TyVar {P.varName = _varName x, P.sourceInfo = P.defSourceInfo}
+_TyVar :: Text -> P.TyVar
+_TyVar x = P.TyVar {P.varName = _VarName x, P.sourceInfo = P.defSourceInfo}
+
+-- | TyVar with Source Info - for error precision testing.
+_TyVar' :: Text -> SourceInfo -> P.TyVar
+_TyVar' x s = P.TyVar {P.varName = _VarName x, P.sourceInfo = s}
 
 _TyVarI :: Text -> P.Ty
-_TyVarI x = P.TyVarI $ P.TyVar {P.varName = _varName x, P.sourceInfo = P.defSourceInfo}
+_TyVarI x = P.TyVarI $ P.TyVar {P.varName = _VarName x, P.sourceInfo = P.defSourceInfo}
+
+-- | TyVar with Source Info - for error precision testing.
+_TyVarI' :: Text -> SourceInfo -> P.Ty
+_TyVarI' x s = P.TyVarI $ P.TyVar {P.varName = _VarName x, P.sourceInfo = s}
+
+_SourceInfo :: Int -> Int -> P.SourceInfo
+_SourceInfo x y = P.SourceInfo {P.file = "DefaultFile", P.posFrom = _SourcePosition x, P.posTo = _SourcePosition y}
+
+_SourcePosition :: Int -> P.SourcePosition
+_SourcePosition x = P.SourcePosition x (x + 1)
 
 _TupleI :: [P.Ty] -> P.Product
 _TupleI x =

lambda-buffers-compiler/test/Test/Utils/Module.hs

@@ -1,8 +1,8 @@
-module Test.Utils.Module (module'maybe, module'incoherent) where
+module Test.Utils.Module (module'maybe, module'incoherent, module'undefinedVar) where
 
 import LambdaBuffers.Compiler.ProtoCompat qualified as P
 import Test.Utils.Constructors (_Module, _ModuleName)
-import Test.Utils.TyDef (tyDef'incoherent, tyDef'maybe)
+import Test.Utils.TyDef (tyDef'incoherent, tyDef'maybe, tyDef'undefinedVar)
 
 -- _Module mn tds cds ins =
 
@@ -20,3 +20,11 @@ module'maybe = _Module (_ModuleName ["Module"]) [tyDef'maybe] mempty mempty
 -}
 module'incoherent :: P.Module
 module'incoherent = _Module (_ModuleName ["Module"]) [tyDef'maybe, tyDef'incoherent] mempty mempty
+
+{- | 1 Module containing
+  Foo = Bar b
+
+  Should fail as b is undefined.
+-}
+module'undefinedVar :: P.Module
+module'undefinedVar = _Module (_ModuleName ["Module"]) [tyDef'undefinedVar] mempty mempty

lambda-buffers-compiler/test/Test/Utils/TyDef.hs

@@ -1,21 +1,24 @@
-module Test.Utils.TyDef (tyDef'maybe, tyDef'incoherent) where
+module Test.Utils.TyDef (tyDef'maybe, tyDef'incoherent, tyDef'undefinedVar, tyDef'undefinedVar'var) where
 
 import LambdaBuffers.Compiler.ProtoCompat qualified as P
+import LambdaBuffers.Compiler.ProtoCompat.Types (Ty (TyVarI))
 import Test.Utils.Constructors (
+  _SourceInfo,
   _TupleI,
   _TyAbs,
   _TyDef,
+  _TyName,
   _TyRefILocal,
+  _TyVar',
   _TyVarI,
   _Type,
-  _tyName,
  )
 
 -- | Maybe tyDef.
 tyDef'maybe :: P.TyDef
 tyDef'maybe =
   _TyDef
-    (_tyName "Maybe")
+    (_TyName "Maybe")
     ( _TyAbs
         [("a", _Type)]
         [ ("Nothing", _TupleI [])
@@ -27,10 +30,21 @@ tyDef'maybe =
 tyDef'incoherent :: P.TyDef
 tyDef'incoherent =
   _TyDef
-    (_tyName "B")
+    (_TyName "B")
     ( _TyAbs
         [("a", _Type)]
         [ ("Nothing", _TupleI [])
         , ("B", _TupleI [_TyRefILocal "Maybe"])
         ]
     )
+
+-- | Foo = Bar b
+tyDef'undefinedVar :: P.TyDef
+tyDef'undefinedVar =
+  _TyDef
+    (_TyName "Foo")
+    (_TyAbs [] [("Bar", _TupleI [TyVarI tyDef'undefinedVar'var])])
+
+-- | The undefined var in tyDef'undefinedVar - exported to see if the test identifies it correctly.
+tyDef'undefinedVar'var :: P.TyVar
+tyDef'undefinedVar'var = _TyVar' "b" (_SourceInfo 1 2)