Merge remote-tracking branch 'origin/main' into bladyjoker/compiler-class-check

Author: bladyjoker

README.md

@@ -102,8 +102,9 @@ nix profile install nixpkgs#direnv
 nix profile install nixpkgs#nix-direnv
 ```
 
-Your shell and editors should pick up on the `.envrc` files in different directories and prepare the environment accordingly.
-Use `direnv allow` to enable the direnv environment and `direnv reload` to reload it when necessary.
+Your shell and editors should pick up on the `.envrc` files in different
+directories and prepare the environment accordingly.  Use `direnv allow` to
+enable the direnv environment and `direnv reload` to reload it when necessary.
 
 Additionally, throughout the repository one can use:
 

lambda-buffers-compiler/app/LambdaBuffers/Compiler/Cli/Compile.hs

@@ -1,15 +1,16 @@
 module LambdaBuffers.Compiler.Cli.Compile (CompileOpts (..), compile) where
 
-import Control.Lens (makeLenses)
+import Control.Lens (makeLenses, (&), (.~))
 import Control.Lens.Getter ((^.))
 import Data.ByteString qualified as BS
+import Data.ProtoLens (Message (defMessage))
 import Data.ProtoLens qualified as Pb
 import Data.ProtoLens.TextFormat qualified as PbText
 import Data.Text.Lazy qualified as Text
 import Data.Text.Lazy.IO qualified as Text
-import LambdaBuffers.Compiler.ProtoCompat (FromProtoErr (NamingError, ProtoError), IsMessage (fromProto, toProto))
-import LambdaBuffers.Compiler.ProtoCompat.Types qualified as ProtoCompat
-import Proto.Compiler (CompilerInput)
+import LambdaBuffers.Compiler (runCompiler)
+import Proto.Compiler (CompilerError, CompilerInput, CompilerOutput)
+import Proto.Compiler_Fields (compilerError, compilerResult)
 import System.FilePath.Lens (extension)
 
 data CompileOpts = CompileOpts
@@ -20,18 +21,19 @@ data CompileOpts = CompileOpts
 
 makeLenses ''CompileOpts
 
+-- NOTE(cstml): Let's use Katip instead of print.
+
 -- | Compile LambdaBuffers modules
 compile :: CompileOpts -> IO ()
 compile opts = do
-  compIn <- readCompilerInput (opts ^. input)
-  case fromProto @CompilerInput @ProtoCompat.CompilerInput compIn of
-    Left err -> case err of
-      NamingError ne -> print $ "Encountered a naming error " <> show ne
-      ProtoError pe -> print $ "Encountered a proto error " <> show pe
-    Right compIn' -> do
-      print @String "Successfully processed the CompilerInput"
-      writeCompilerOutput (opts ^. output) (toProto compIn')
-
+  compInp <- readCompilerInput (opts ^. input)
+  case runCompiler compInp of
+    Left compErr -> do
+      putStrLn "Encountered errors during Compilation"
+      writeCompilerError (opts ^. output) compErr
+    Right compRes -> do
+      putStrLn "Compilation succeeded"
+      writeCompilerOutput (opts ^. output) (defMessage & compilerResult .~ compRes)
   return ()
 
 readCompilerInput :: FilePath -> IO CompilerInput
@@ -46,11 +48,13 @@ readCompilerInput fp = do
       return $ PbText.readMessageOrDie content
     _ -> error $ "Unknown CompilerInput format " <> ext
 
--- FIXME(bladyjoker): Do this properly when you figure out what the CompilerOutput is.
-writeCompilerOutput :: FilePath -> CompilerInput -> IO ()
-writeCompilerOutput fp co = do
+writeCompilerError :: FilePath -> CompilerError -> IO ()
+writeCompilerError fp err = writeCompilerOutput fp (defMessage & compilerError .~ err)
+
+writeCompilerOutput :: FilePath -> CompilerOutput -> IO ()
+writeCompilerOutput fp cr = do
   let ext = fp ^. extension
   case ext of
-    ".pb" -> BS.writeFile fp (Pb.encodeMessage co)
-    ".textproto" -> Text.writeFile fp (Text.pack . show $ PbText.pprintMessage co)
+    ".pb" -> BS.writeFile fp (Pb.encodeMessage cr)
+    ".textproto" -> Text.writeFile fp (Text.pack . show $ PbText.pprintMessage cr)
     _ -> error $ "Unknown CompilerOutput format " <> ext

lambda-buffers-compiler/app/Main.hs

@@ -23,8 +23,7 @@ import Options.Applicative (
   subparser,
  )
 
-newtype Command
-  = Compile CompileOpts
+newtype Command = Compile CompileOpts
 
 inputPathP :: Parser FilePath
 inputPathP =

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

@@ -37,7 +37,9 @@ common common-language
     DeriveLift
     DeriveTraversable
     DerivingStrategies
+    DerivingVia
     DoAndIfThenElse
+    DuplicateRecordFields
     EmptyCase
     EmptyDataDecls
     EmptyDataDeriving
@@ -59,6 +61,7 @@ common common-language
     NamedFieldPuns
     NamedWildCards
     NumericUnderscores
+    OverloadedLabels
     OverloadedStrings
     PartialTypeSignatures
     PatternGuards
@@ -92,29 +95,40 @@ library
   build-depends:
     , containers                  >=0.6.5.1
     , freer-simple                >=1.2
+    , generic-arbitrary
     , generic-lens                >=2.2
     , lambda-buffers-compiler-pb  >=0.1.0.0
     , mtl                         >=2.2
     , parsec                      >=3.1
     , prettyprinter               >=1.7
     , proto-lens                  >=0.7
+    , QuickCheck                  >=2.14
+    , quickcheck-instances        >=0.3
     , text                        >=1.2
 
   exposed-modules:
-    LambdaBuffers.Compiler.Canonical
+    LambdaBuffers.Compiler
     LambdaBuffers.Compiler.KindCheck
     LambdaBuffers.Compiler.KindCheck.Context
+    LambdaBuffers.Compiler.KindCheck.Derivation
     LambdaBuffers.Compiler.KindCheck.Inference
+    LambdaBuffers.Compiler.KindCheck.Judgement
     LambdaBuffers.Compiler.KindCheck.Kind
     LambdaBuffers.Compiler.KindCheck.Type
     LambdaBuffers.Compiler.KindCheck.Variable
     LambdaBuffers.Compiler.NamingCheck
     LambdaBuffers.Compiler.ProtoCompat
+    LambdaBuffers.Compiler.ProtoCompat.FromProto
     LambdaBuffers.Compiler.ProtoCompat.Types
+    LambdaBuffers.Compiler.TypeClass.Pat
+    LambdaBuffers.Compiler.TypeClass.Pretty
+    LambdaBuffers.Compiler.TypeClass.Rules
+    LambdaBuffers.Compiler.TypeClass.Solve
     LambdaBuffers.Compiler.TypeClassCheck
 
   hs-source-dirs:  src
 
+-- NOTE(cstml): should we name this something shorter? lb-cli?
 executable lambda-buffers-compiler-cli
   import:         common-language
   import:         common-imports
@@ -137,13 +151,23 @@ test-suite tests
   hs-source-dirs: test
   main-is:        Test.hs
   build-depends:
+    , containers                  >=0.6
     , lambda-buffers-compiler
     , lambda-buffers-compiler-pb  >=0.1
+    , mtl                         >=2.2
     , proto-lens                  >=0.7
+    , QuickCheck                  >=2.14
     , tasty                       >=1.4
     , tasty-hunit                 >=0.10
+    , tasty-quickcheck            >=0.10
     , text                        >=1.2
 
   other-modules:
     Test.KindCheck
+    Test.LambdaBuffers.Compiler
+    Test.LambdaBuffers.Compiler.Gen
     Test.TypeClassCheck
+    Test.Utils.CompilerInput
+    Test.Utils.Constructors
+    Test.Utils.Module
+    Test.Utils.TyDef

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

@@ -0,0 +1,16 @@
+module LambdaBuffers.Compiler (runCompiler) where
+
+import Data.ProtoLens (Message (defMessage))
+import LambdaBuffers.Compiler.KindCheck (check_)
+import LambdaBuffers.Compiler.ProtoCompat.FromProto (
+  runFromProto,
+  toProto,
+ )
+import Proto.Compiler (CompilerError, CompilerInput, CompilerResult)
+
+runCompiler :: CompilerInput -> Either CompilerError CompilerResult
+runCompiler compInp = do
+  compInp' <- runFromProto compInp
+  case check_ compInp' of
+    Left err -> Left $ toProto err
+    Right _ -> Right defMessage