Add proof of concept hard-coded hover handler

A kind of "hello world" LSP plugin.

Tested with emacs lsp-mode by setting "Lsp Haskell Process Path Hie"
to `ide`, and clearing out the "Lsp Haskell Process Args Hie".

.gitignore

@@ -0,0 +1,6 @@
+dist-newstyle
+.stack-work
+hie.yaml
+cabal.project.local
+*~
+*.lock

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project authors. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

README.md

@@ -1,2 +1,16 @@
 # ide
+
 Integration point for ghcide and haskell-ide-engine. One IDE to rule them all.
+
+This is *very* early stage software.
+
+To play along at home, it assumes the ghcide master is checked out at
+`../../digital-asset/ghcide` relative to this one.
+
+Initial effort is to understand how plugins can be supported in a modular way.
+
+Builds with stack and cabal, using GHC 8.6.5
+
+Two sample `hie.yaml` files are provided, `hie.yaml.stack` for stack
+usage, `hie.yaml.cbl` for cabal. Simply copy the relevant one to be
+`hie.yaml` and it should work.

cabal.project

@@ -0,0 +1,10 @@
+packages:
+         ./
+         ../../digital-asset/ghcide
+
+tests: true
+
+package ide
+  test-show-details: direct
+
+write-ghc-environment-files: never

exe/Arguments.hs

@@ -0,0 +1,32 @@
+-- Copyright (c) 2019 The DAML Authors. All rights reserved.
+-- SPDX-License-Identifier: Apache-2.0
+
+module Arguments(Arguments(..), getArguments) where
+
+import Options.Applicative
+
+
+data Arguments = Arguments
+    {argLSP :: Bool
+    ,argsCwd :: Maybe FilePath
+    ,argFiles :: [FilePath]
+    ,argsVersion :: Bool
+    ,argsShakeProfiling :: Maybe FilePath
+    }
+
+getArguments :: IO Arguments
+getArguments = execParser opts
+  where
+    opts = info (arguments <**> helper)
+      ( fullDesc
+     <> progDesc "Used as a test bed to check your IDE will work"
+     <> header "ghcide - the core of a Haskell IDE")
+
+arguments :: Parser Arguments
+arguments = Arguments
+      <$> switch (long "lsp" <> help "Start talking to an LSP server")
+      <*> optional (strOption $ long "cwd" <> metavar "DIR" <> help "Change to this directory")
+      <*> many (argument str (metavar "FILES/DIRS..."))
+      <*> switch (long "version" <> help "Show ghcide and GHC versions")
+      <*> optional (strOption $ long "shake-profiling" <> metavar "DIR" <> help "Dump profiling reports to this directory")
+

exe/Main.hs

@@ -0,0 +1,225 @@
+-- Copyright (c) 2019 The DAML Authors. All rights reserved.
+-- SPDX-License-Identifier: Apache-2.0
+{-# OPTIONS_GHC -Wno-dodgy-imports #-} -- GHC no longer exports def in GHC 8.6 and above
+{-# LANGUAGE CPP #-} -- To get precise GHC version
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ViewPatterns #-}
+{-# LANGUAGE TupleSections #-}
+
+module Main(main) where
+
+import Arguments
+import Data.Maybe
+import Data.List.Extra
+import System.FilePath
+import Control.Concurrent.Extra
+import Control.Exception
+import Control.Monad.Extra
+import Control.Monad.IO.Class
+import Data.Default
+import System.Time.Extra
+import Development.IDE.Core.FileStore
+import Development.IDE.Core.OfInterest
+import Development.IDE.Core.Service
+import Development.IDE.Core.Rules
+import Development.IDE.Core.Shake
+import Development.IDE.Core.RuleTypes
+import Development.IDE.LSP.Protocol
+import Development.IDE.Types.Location
+import Development.IDE.Types.Diagnostics
+import Development.IDE.Types.Options
+import Development.IDE.Types.Logger
+import Development.IDE.GHC.Util
+import qualified Data.Text as T
+import qualified Data.Text.IO as T
+import Language.Haskell.LSP.Messages
+import Language.Haskell.LSP.Types (LspId(IdInt))
+import Linker
+import Data.Version
+import Development.IDE.LSP.LanguageServer
+import System.Directory.Extra as IO
+import System.Environment
+import System.IO
+import System.Exit
+import Paths_ide
+import Development.GitRev
+import Development.Shake (Action, action)
+import qualified Data.Set as Set
+import qualified Data.Map.Strict as Map
+
+import GHC hiding (def)
+import qualified GHC.Paths
+
+import HIE.Bios
+
+-- ---------------------------------------------------------------------
+
+import qualified Ide.Plugin.Example as P
+
+-- ---------------------------------------------------------------------
+
+-- Set the GHC libdir to the nix libdir if it's present.
+getLibdir :: IO FilePath
+getLibdir = fromMaybe GHC.Paths.libdir <$> lookupEnv "NIX_GHC_LIBDIR"
+
+ghcideVersion :: IO String
+ghcideVersion = do
+  path <- getExecutablePath
+  let gitHashSection = case $(gitHash) of
+        x | x == "UNKNOWN" -> ""
+        x -> " (GIT hash: " <> x <> ")"
+  return $ "ghcide version: " <> showVersion version
+             <> " (GHC: " <> VERSION_ghc
+             <> ") (PATH: " <> path <> ")"
+             <> gitHashSection
+
+main :: IO ()
+main = do
+    -- WARNING: If you write to stdout before runLanguageServer
+    --          then the language server will not work
+    Arguments{..} <- getArguments
+
+    if argsVersion then ghcideVersion >>= putStrLn >> exitSuccess
+    else hPutStrLn stderr {- see WARNING above -} =<< ghcideVersion
+
+    -- lock to avoid overlapping output on stdout
+    lock <- newLock
+    let logger p = Logger $ \pri msg -> when (pri >= p) $ withLock lock $
+            T.putStrLn $ T.pack ("[" ++ upper (show pri) ++ "] ") <> msg
+
+    whenJust argsCwd setCurrentDirectory
+
+    dir <- getCurrentDirectory
+
+    if argLSP then do
+        t <- offsetTime
+        hPutStrLn stderr "Starting (ide)LSP server..."
+        hPutStrLn stderr "If you are seeing this in a terminal, you probably should have run ide WITHOUT the --lsp option!"
+        runLanguageServer def P.setHandlersExample $ \getLspId event vfs caps -> do
+            t <- t
+            hPutStrLn stderr $ "Started LSP server in " ++ showDuration t
+            -- very important we only call loadSession once, and it's fast, so just do it before starting
+            session <- loadSession dir
+            let options = (defaultIdeOptions $ return session)
+                    { optReportProgress = clientSupportsProgress caps
+                    , optShakeProfiling = argsShakeProfiling
+                    }
+            initialise caps (mainRule >> action kick) getLspId event (logger minBound) options vfs
+    else do
+        putStrLn $ "Ghcide setup tester in " ++ dir ++ "."
+        putStrLn "Report bugs at https://github.com/digital-asset/ghcide/issues"
+
+        putStrLn $ "\nStep 1/6: Finding files to test in " ++ dir
+        files <- nubOrd <$> expandFiles (argFiles ++ ["." | null argFiles])
+        putStrLn $ "Found " ++ show (length files) ++ " files"
+
+        putStrLn "\nStep 2/6: Looking for hie.yaml files that control setup"
+        cradles <- mapM findCradle files
+        let ucradles = nubOrd cradles
+        let n = length ucradles
+        putStrLn $ "Found " ++ show n ++ " cradle" ++ ['s' | n /= 1]
+        sessions <- forM (zipFrom (1 :: Int) ucradles) $ \(i, x) -> do
+            let msg = maybe ("Implicit cradle for " ++ dir) ("Loading " ++) x
+            putStrLn $ "\nStep 3/6, Cradle " ++ show i ++ "/" ++ show n ++ ": " ++ msg
+            cradle <- maybe (loadImplicitCradle $ addTrailingPathSeparator dir) loadCradle x
+            when (isNothing x) $ print cradle
+            putStrLn $ "\nStep 4/6, Cradle " ++ show i ++ "/" ++ show n ++ ": Loading GHC Session"
+            cradleToSession cradle
+
+        putStrLn "\nStep 5/6: Initializing the IDE"
+        vfs <- makeVFSHandle
+        let cradlesToSessions = Map.fromList $ zip ucradles sessions
+        let filesToCradles = Map.fromList $ zip files cradles
+        let grab file = fromMaybe (head sessions) $ do
+                cradle <- Map.lookup file filesToCradles
+                Map.lookup cradle cradlesToSessions
+        ide <- initialise def mainRule (pure $ IdInt 0) (showEvent lock) (logger Info) (defaultIdeOptions $ return $ return . grab) vfs
+
+        putStrLn "\nStep 6/6: Type checking the files"
+        setFilesOfInterest ide $ Set.fromList $ map toNormalizedFilePath files
+        results <- runActionSync ide $ uses TypeCheck $ map toNormalizedFilePath files
+        let (worked, failed) = partition fst $ zip (map isJust results) files
+        when (failed /= []) $
+            putStr $ unlines $ "Files that failed:" : map ((++) " * " . snd) failed
+
+        let files xs = let n = length xs in if n == 1 then "1 file" else show n ++ " files"
+        putStrLn $ "\nCompleted (" ++ files worked ++ " worked, " ++ files failed ++ " failed)"
+
+        unless (null failed) exitFailure
+
+
+expandFiles :: [FilePath] -> IO [FilePath]
+expandFiles = concatMapM $ \x -> do
+    b <- IO.doesFileExist x
+    if b then return [x] else do
+        let recurse "." = True
+            recurse x | "." `isPrefixOf` takeFileName x = False -- skip .git etc
+            recurse x = takeFileName x `notElem` ["dist","dist-newstyle"] -- cabal directories
+        files <- filter (\x -> takeExtension x `elem` [".hs",".lhs"]) <$> listFilesInside (return . recurse) x
+        when (null files) $
+            fail $ "Couldn't find any .hs/.lhs files inside directory: " ++ x
+        return files
+
+
+kick :: Action ()
+kick = do
+    files <- getFilesOfInterest
+    void $ uses TypeCheck $ Set.toList files
+
+-- | Print an LSP event.
+showEvent :: Lock -> FromServerMessage -> IO ()
+showEvent _ (EventFileDiagnostics _ []) = return ()
+showEvent lock (EventFileDiagnostics (toNormalizedFilePath -> file) diags) =
+    withLock lock $ T.putStrLn $ showDiagnosticsColored $ map (file,ShowDiag,) diags
+showEvent lock e = withLock lock $ print e
+
+
+cradleToSession :: Cradle -> IO HscEnvEq
+cradleToSession cradle = do
+    cradleRes <- getCompilerOptions "" cradle
+    opts <- case cradleRes of
+        CradleSuccess r -> pure r
+        CradleFail err -> throwIO err
+        -- TODO Rather than failing here, we should ignore any files that use this cradle.
+        -- That will require some more changes.
+        CradleNone -> fail "'none' cradle is not yet supported"
+    libdir <- getLibdir
+    env <- runGhc (Just libdir) $ do
+        _targets <- initSession opts
+        getSession
+    initDynLinker env
+    newHscEnvEq env
+
+
+loadSession :: FilePath -> IO (FilePath -> Action HscEnvEq)
+loadSession dir = do
+    cradleLoc <- memoIO $ \v -> do
+        res <- findCradle v
+        -- Sometimes we get C:, sometimes we get c:, and sometimes we get a relative path
+        -- try and normalise that
+        -- e.g. see https://github.com/digital-asset/ghcide/issues/126
+        res' <- traverse makeAbsolute res
+        return $ normalise <$> res'
+    session <- memoIO $ \file -> do
+        c <- maybe (loadImplicitCradle $ addTrailingPathSeparator dir) loadCradle file
+        cradleToSession c
+    return $ \file -> liftIO $ session =<< cradleLoc file
+
+
+-- | Memoize an IO function, with the characteristics:
+--
+--   * If multiple people ask for a result simultaneously, make sure you only compute it once.
+--
+--   * If there are exceptions, repeatedly reraise them.
+--
+--   * If the caller is aborted (async exception) finish computing it anyway.
+memoIO :: Ord a => (a -> IO b) -> IO (a -> IO b)
+memoIO op = do
+    ref <- newVar Map.empty
+    return $ \k -> join $ mask_ $ modifyVar ref $ \mp ->
+        case Map.lookup k mp of
+            Nothing -> do
+                res <- onceFork $ op k
+                return (Map.insert k res mp, res)
+            Just res -> return (mp, res)

hie.yaml.cbl

@@ -0,0 +1,15 @@
+# This is a sample hie.yaml file for opening haskell-ide-engine in
+# hie, using cabal as the build system.
+# To use is, copy it to a file called 'hie.yaml'
+
+cradle:
+  cabal:
+
+    - path: "./test"
+      component: "ide:test"
+
+    - path: "./exe"
+      component: "ide:exe:ide"
+
+    - path: "./src"
+      component: "lib:ide"