eval: avoid usage of term "test"; instead use "evalExpr"

Author: dschrempf

plugins/hls-eval-plugin/src/Ide/Plugin/Eval/Code.hs

@@ -5,10 +5,10 @@
 -- | Expression execution
 module Ide.Plugin.Eval.Code (
     Statement
-  , testRanges
+  , evalExprRanges
   , resultRange
   , propSetup
-  , testCheck
+  , evalExprCheck
   , asStatements
   , execStmtCaptureResult
   ) where
@@ -27,21 +27,21 @@ import           GHC                         (ExecOptions, ExecResult (..),
 import           Ide.Logger                  (Recorder, WithPriority, logWith)
 import qualified Ide.Logger                  as Log
 
-import           Ide.Plugin.Eval.Types       (Language (Plain), Loc,
-                                              Located (..), Log (..),
-                                              Section (sectionLanguage),
-                                              Test (..), Txt, locate, locate0)
+import           Ide.Plugin.Eval.Types       (EvalExpr (..), Language (Plain),
+                                              Loc, Located (..), Log (..),
+                                              Section (sectionLanguage), Txt,
+                                              locate, locate0)
 import           Ide.Plugin.Eval.Util        (gStrictTry)
 import qualified Language.LSP.Protocol.Lens  as L
 import           Language.LSP.Protocol.Types (Position (Position),
                                               Range (Range))
 import           System.IO.Extra             (newTempFile, readFile')
 
--- | Return the ranges of the expression and result parts of the given test
-testRanges :: Test -> (Range, Range)
-testRanges tst =
-    let startLine = testRange tst ^. L.start . L.line
-        (fromIntegral -> exprLines, fromIntegral -> resultLines) = testLengths tst
+-- | Return the ranges of the expression and result parts of the given 'EvalExpr'.
+evalExprRanges :: EvalExpr -> (Range, Range)
+evalExprRanges tst =
+    let startLine = evalExprRange tst ^. L.start . L.line
+        (fromIntegral -> exprLines, fromIntegral -> resultLines) = evalExprLengths tst
         resLine = startLine + exprLines
      in ( Range
             (Position startLine 0)
@@ -50,14 +50,9 @@ testRanges tst =
         , Range (Position resLine 0) (Position (resLine + resultLines) 0)
         )
 
-{- |The document range where a test is defined
- testRange :: Loc Test -> Range
- testRange = fst . testRanges
--}
-
--- |The document range where the result of the test is defined
-resultRange :: Test -> Range
-resultRange = snd . testRanges
+-- | The document range where the result of the 'EvalExpr' is defined.
+resultRange :: EvalExpr -> Range
+resultRange = snd . evalExprRanges
 
 -- TODO: handle BLANKLINE
 {-
@@ -72,30 +67,31 @@ showDiff (First w)  = "WAS " <> w
 showDiff (Second w) = "NOW " <> w
 showDiff (Both w _) = w
 
--- | Compare the expected output recorded in the test with the actual output
--- @out@. When diffing is enabled and there is a recorded output, return a
--- line-by-line diff (see 'showDiffs'); otherwise return @out@ unchanged.
-testCheck :: Bool -> (Section, Test) -> [T.Text] -> [T.Text]
-testCheck diff (section, test) out
-    | not diff || null (testOutput test) || sectionLanguage section == Plain = out
-    | otherwise = showDiffs $ getDiff (map T.pack $ testOutput test) out
+-- | Compare the expected output recorded in the 'EvalExpr' with the actual
+-- output @out@. When diffing is enabled and there is a recorded output, return
+-- a line-by-line diff (see 'showDiffs'); otherwise return @out@ unchanged.
+evalExprCheck :: Bool -> (Section, EvalExpr) -> [T.Text] -> [T.Text]
+evalExprCheck diff (section, evalExpr) out
+    | not diff || null (evalExprOutput evalExpr) || sectionLanguage section == Plain = out
+    | otherwise = showDiffs $ getDiff (map T.pack $ evalExprOutput evalExpr) out
 
--- | The number of (expression lines, result lines) a test occupies.
-testLengths :: Test -> (Int, Int)
-testLengths (Example e r _)  = (NE.length e, length r)
-testLengths (Property _ r _) = (1, length r)
+-- | The number of (expression lines, result lines) an 'EvalExpr' occupies.
+evalExprLengths :: EvalExpr -> (Int, Int)
+evalExprLengths (Example e r _)  = (NE.length e, length r)
+evalExprLengths (Property _ r _) = (1, length r)
 
 -- |A one-line Haskell statement
 type Statement = Loc String
 
--- | The Haskell statements to feed to GHCi for a test, each tagged with its
--- source line so evaluation errors can be located.
-asStatements :: Test -> [Statement]
-asStatements lt = locate $ Located (fromIntegral $ testRange lt ^. L.start . L.line) (asStmts lt)
+-- | The Haskell statements to feed to GHCi for an 'EvalExpr', each tagged with
+-- its source line so evaluation errors can be located.
+asStatements :: EvalExpr -> [Statement]
+asStatements lt =
+  locate $ Located (fromIntegral $ evalExprRange lt ^. L.start . L.line) (asStmts lt)
 
--- | The raw statement lines of a test. A 'Property' is wrapped so its result
--- is evaluated through 'propEvaluation' (see 'propSetup').
-asStmts :: Test -> [Txt]
+-- | The raw statement lines of an 'EvalExpr'. A 'Property' is wrapped so its
+-- result is evaluated through 'propEvaluation' (see 'propSetup').
+asStmts :: EvalExpr -> [Txt]
 asStmts (Example e _ _) = NE.toList e
 asStmts (Property t _ _) =
     ["prop11 = " ++ t, "(propEvaluation prop11 :: IO String)"]
@@ -210,15 +206,15 @@ captureTeardown = unwords
     , "  }"
     ]
 
-{- |GHC declarations required to execute test properties
+{- | GHC declarations required to evaluate property 'EvalExprs'
 
 Example:
 
 prop> \(l::[Bool]) -> reverse (reverse l) == l
-+++ OK, passed 100 tests.
++++ OK, passed 100 evalExprs.
 
 prop> \(l::[Bool]) -> reverse l == l
-*** Failed! Falsified (after 6 tests and 2 shrinks):
+*** Failed! Falsified (after 6 evalExprs and 2 shrinks):
 [True,False]
 -}
 propSetup :: [Loc [Char]]

plugins/hls-eval-plugin/src/Ide/Plugin/Eval/Handlers.hs

@@ -102,8 +102,8 @@ import           Ide.Plugin.Eval.Code                         (Statement,
                                                                execStmtCaptureResult,
                                                                propSetup,
                                                                resultRange,
-                                                               testCheck,
-                                                               testRanges)
+                                                               evalExprCheck,
+                                                               evalExprRanges)
 import           Ide.Plugin.Eval.Config                       (EvalConfig (..),
                                                                getEvalConfig)
 import           Ide.Plugin.Eval.GHC                          (addImport,
@@ -134,8 +134,8 @@ codeAction recorder st plId CodeActionParams{_textDocument,_range} = do
     pure
         $ InL
             [ InL command
-            | (testRange, command) <- rangeCommands
-            , _range `isSubrangeOf` testRange
+            | (evalExprRange, command) <- rangeCommands
+            , _range `isSubrangeOf` evalExprRange
             ]
 
 {- | Code Lens provider
@@ -150,7 +150,7 @@ codeLens recorder st plId CodeLensParams{_textDocument} = do
             | (range, command) <- rangeCommands
             ]
 
--- | Find every test in the document and pair its source range with the
+-- | Find every eval-expr in the document and pair its source range with the
 -- 'Command' that evaluates it. Shared by the code action and code lens
 -- providers.
 mkRangeCommands :: Recorder (WithPriority Log) -> IdeState -> PluginId -> TextDocumentIdentifier -> ExceptT PluginError (HandlerM Config) [(Range, Command)]
@@ -168,14 +168,14 @@ mkRangeCommands recorder st plId textDocument =
                     runActionE "eval.GetParsedModuleWithComments" st $ useWithStaleE GetEvalComments nfp
                 dbg $ LogCodeLensComments comments
 
-                -- Extract tests from source code
+                -- Extract 'EvalExpr's from source code
                 let Sections{..} = commentsToSections isLHS comments
-                    tests = testsBySection nonSetupSections
+                    evalExprs = evalExprsBySection nonSetupSections
                     cmd = mkLspCommand plId evalCommandName "Evaluate=..." (Just [])
                 let rangeCommands =
-                        [ (testRange, cmd')
-                        | (section, ident, test) <- tests
-                        , let (testRange, resultRange) = testRanges test
+                        [ (evalExprRange, cmd')
+                        | (section, ident, evalExpr) <- evalExprs
+                        , let (evalExprRange, resultRange) = evalExprRanges evalExpr
                               args = EvalParams (setupSections ++ [section]) textDocument ident
                               cmd' =
                                 (cmd :: Command)
@@ -187,9 +187,9 @@ mkRangeCommands recorder st plId textDocument =
                                     }
                         ]
 
-                perf "tests" $
-                    dbg $ LogTests
-                            (length tests)
+                perf "evalExprs" $
+                    dbg $ LogEvalExprs
+                            (length evalExprs)
                             (length nonSetupSections)
                             (length setupSections)
                             (length rangeCommands)
@@ -212,7 +212,7 @@ runEvalCmd recorder plId st mtoken EvalParams{..} =
         perf = timed (\lbl duration -> dbg $ LogExecutionTime lbl duration)
         cmd :: ExceptT PluginError (HandlerM Config) WorkspaceEdit
         cmd = do
-            let tests = map (\(a,_,b) -> (a,b)) $ testsBySection sections
+            let evalExprs = map (\(a,_,b) -> (a,b)) $ evalExprsBySection sections
 
             let TextDocumentIdentifier{_uri} = module_
             fp <- uriToFilePathE _uri
@@ -229,7 +229,7 @@ runEvalCmd recorder plId st mtoken EvalParams{..} =
                 unqueueForEvaluation st nfp
                 return [toKey IsEvaluating nfp]
                 )
-              (initialiseSessionForEval (needsQuickCheck tests) st nfp)
+              (initialiseSessionForEval (needsQuickCheck evalExprs) st nfp)
 
             evalCfg <- liftIO $ runAction "eval: config" st $ getEvalConfig plId
 
@@ -238,7 +238,7 @@ runEvalCmd recorder plId st mtoken EvalParams{..} =
                 perf "edits" $
                     liftIO $
                         evalGhcEnv final_hscEnv $ do
-                            runTests recorder evalCfg fp tests
+                            runEvalExprs recorder evalCfg fp evalExprs
 
             let workspaceEditsMap = Map.singleton _uri (addFinalReturn mdlText edits)
             let workspaceEdits = WorkspaceEdit (Just workspaceEditsMap) Nothing Nothing
@@ -359,13 +359,13 @@ moduleText state uri = do
                         toNormalizedUri uri
     pure $ Rope.toText contents
 
--- | Flatten sections into their individual tests, tagging each with the index
+-- | Flatten sections into their individual 'EvalExpr's, tagging each with the index
 -- ('EvalId') of its containing section.
-testsBySection :: [Section] -> [(Section, EvalId, Test)]
-testsBySection sections =
-    [(section, ident, test)
+evalExprsBySection :: [Section] -> [(Section, EvalId, EvalExpr)]
+evalExprsBySection sections =
+    [(section, ident, evalExpr)
     | (ident, section) <- zip [0..] sections
-    , test <- sectionTests section
+    , evalExpr <- sectionEvalExprs section
     ]
 
 type TEnv = String
@@ -382,59 +382,59 @@ evalSetup = do
     context <- getContext
     setContext (IIDecl preludeAsP : IIDecl systemIO : IIDecl ghcIOHandle : context)
 
--- | Evaluate every test and produce the 'TextEdit's that write the results
+-- | Evaluate every 'EvalExpr' and produce the 'TextEdit's that write the results
 -- back into the document, prefixing/padding each result line as the section's
 -- format requires.
-runTests :: Recorder (WithPriority Log) -> EvalConfig -> TEnv -> [(Section, Test)] -> Ghc [TextEdit]
-runTests recorder EvalConfig{..} e tests = do
+runEvalExprs :: Recorder (WithPriority Log) -> EvalConfig -> TEnv -> [(Section, EvalExpr)] -> Ghc [TextEdit]
+runEvalExprs recorder EvalConfig{..} e evalExprs = do
     df <- getInteractiveDynFlags
     evalSetup
-    when (hasQuickCheck df && needsQuickCheck tests) $ void $ evals recorder True e df propSetup
+    when (hasQuickCheck df && needsQuickCheck evalExprs) $ void $ evals recorder True e df propSetup
 
-    mapM (processTest e df) tests
+    mapM (processEvalExpr e df) evalExprs
   where
-    processTest :: TEnv -> DynFlags -> (Section, Test) -> Ghc TextEdit
-    processTest fp df (section, test) = do
+    processEvalExpr :: TEnv -> DynFlags -> (Section, EvalExpr) -> Ghc TextEdit
+    processEvalExpr fp df (section, evalExpr) = do
         let dbg = logWith recorder Debug
         let pad = pad_ $ (if isLiterate fp then ("> " `T.append`) else id) $ padPrefix (sectionFormat section)
-        rs <- runTest e df test
-        dbg $ LogRunTestResults rs
+        rs <- runEvalExpr e df evalExpr
+        dbg $ LogRunEvalExprResults rs
 
-        let checkedResult = testCheck eval_cfg_diff (section, test) rs
+        let checkedResult = evalExprCheck eval_cfg_diff (section, evalExpr) rs
         let resultLines = concatMap T.lines checkedResult
 
-        let edit = asEdit (sectionFormat section) test (map pad resultLines)
-        dbg $ LogRunTestEdits edit
+        let edit = asEdit (sectionFormat section) evalExpr (map pad resultLines)
+        dbg $ LogRunEvalExprEdits edit
         return edit
 
-    -- runTest :: String -> DynFlags -> Loc Test -> Ghc [Text]
-    runTest _ df test
-        | not (hasQuickCheck df) && isProperty test =
+    -- runEvalExpr :: String -> DynFlags -> Loc EvalExpr -> Ghc [Text]
+    runEvalExpr _ df evalExpr
+        | not (hasQuickCheck df) && isProperty evalExpr =
             return $
                 singleLine
-                    "Add QuickCheck to your cabal dependencies to run this test."
-    runTest e df test = evals recorder (eval_cfg_exception && not (isProperty test)) e df (asStatements test)
-
--- | Build the edit that replaces a test's old result with @resultLines@. For a
--- test that sits on the closing @-}@ line of a block comment, the result is
--- inserted before @-}@ on fresh lines; otherwise it simply overwrites the
--- existing result range.
-asEdit :: Format -> Test -> [Text] -> TextEdit
-asEdit (MultiLine commRange) test resultLines
-    -- A test in a block comment, ending with @-\}@ without newline in-between.
-    | testRange test ^. L.end . L.line == commRange ^. L.end . L.line
+                    "Add QuickCheck to your cabal dependencies to run this property."
+    runEvalExpr e df evalExpr = evals recorder (eval_cfg_exception && not (isProperty evalExpr)) e df (asStatements evalExpr)
+
+-- | Build the edit that replaces the old result of an 'EvalExpr' with
+-- @resultLines@. For an 'EvalExpr' that sits on the closing @-}@ line of a
+-- block comment, the result is inserted before @-}@ on fresh lines; otherwise
+-- it simply overwrites the existing result range.
+asEdit :: Format -> EvalExpr -> [Text] -> TextEdit
+asEdit (MultiLine commRange) evalExpr resultLines
+    -- An 'EvalExpr' in a block comment, ending with @-\}@ without newline in-between.
+    | evalExprRange evalExpr ^. L.end . L.line == commRange ^. L.end . L.line
     =
     TextEdit
         (Range
-            (testRange test ^. L.end)
-            (resultRange test ^. L.end)
+            (evalExprRange evalExpr ^. L.end)
+            (resultRange evalExpr ^. L.end)
         )
         ("\n" <> T.unlines (resultLines <> ["-}"]))
-asEdit _ test resultLines =
-    TextEdit (resultRange test) (T.unlines resultLines)
+asEdit _ evalExpr resultLines =
+    TextEdit (resultRange evalExpr) (T.unlines resultLines)
 
 {- |
-The result of evaluating a test line can be:
+The result of evaluating an eval-expr line can be:
 * a value
 * nothing
 * a (possibly multiline) error message
@@ -576,7 +576,7 @@ evals recorder mark_exception fp df stmts = do
         let opts = execOptions{execSourceFile = fp, execLineNumber = l}
          in execStmtCaptureResult recorder stmt opts
 
-needsQuickCheck :: [(Section, Test)] -> Bool
+needsQuickCheck :: [(Section, EvalExpr)] -> Bool
 needsQuickCheck = any (isProperty . snd)
 
 hasQuickCheck :: DynFlags -> Bool