{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}
module Futhark.Compiler.Program
( readLibraryWithBasis,
readImports,
Imports,
FileModule (..),
E.Warnings,
Basis (..),
emptyBasis,
)
where
import Control.Exception
import Control.Monad
import Control.Monad.Except
import Control.Monad.Reader
import Control.Monad.State
import Data.List (intercalate)
import Data.Maybe
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Futhark.Error
import Futhark.FreshNames
import Futhark.Util.Pretty (line, ppr, (</>))
import qualified Language.Futhark as E
import Language.Futhark.Parser
import Language.Futhark.Prelude
import Language.Futhark.Semantic
import qualified Language.Futhark.TypeChecker as E
import Language.Futhark.Warnings
import qualified System.FilePath.Posix as Posix
import System.IO.Error
type CompilerM m = ReaderT [FilePath] (StateT ReaderState m)
data ReaderState = ReaderState
{ ReaderState -> Imports
alreadyImported :: Imports,
ReaderState -> VNameSource
nameSource :: VNameSource,
ReaderState -> Warnings
warnings :: E.Warnings
}
data Basis = Basis
{ Basis -> Imports
basisImports :: Imports,
Basis -> VNameSource
basisNameSource :: VNameSource,
Basis -> [String]
basisRoots :: [String]
}
emptyBasis :: Basis
emptyBasis :: Basis
emptyBasis =
Basis :: Imports -> VNameSource -> [String] -> Basis
Basis
{ basisImports :: Imports
basisImports = Imports
forall a. Monoid a => a
mempty,
basisNameSource :: VNameSource
basisNameSource = VNameSource
src,
basisRoots :: [String]
basisRoots = [String]
forall a. Monoid a => a
mempty
}
where
src :: VNameSource
src = Int -> VNameSource
newNameSource (Int -> VNameSource) -> Int -> VNameSource
forall a b. (a -> b) -> a -> b
$ Int
E.maxIntrinsicTag Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
readImport ::
(MonadError CompilerError m, MonadIO m) =>
[ImportName] ->
ImportName ->
CompilerM m ()
readImport :: [ImportName] -> ImportName -> CompilerM m ()
readImport [ImportName]
steps ImportName
include
| ImportName
include ImportName -> [ImportName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ImportName]
steps =
String -> CompilerM m ()
forall (m :: * -> *) a. MonadError CompilerError m => String -> m a
externalErrorS (String -> CompilerM m ()) -> String -> CompilerM m ()
forall a b. (a -> b) -> a -> b
$
String
"Import cycle: "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate
String
" -> "
((ImportName -> String) -> [ImportName] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ImportName -> String
includeToString ([ImportName] -> [String]) -> [ImportName] -> [String]
forall a b. (a -> b) -> a -> b
$ [ImportName] -> [ImportName]
forall a. [a] -> [a]
reverse ([ImportName] -> [ImportName]) -> [ImportName] -> [ImportName]
forall a b. (a -> b) -> a -> b
$ ImportName
include ImportName -> [ImportName] -> [ImportName]
forall a. a -> [a] -> [a]
: [ImportName]
steps)
| Bool
otherwise = do
Bool
already_done <- (ReaderState -> Bool)
-> ReaderT [String] (StateT ReaderState m) Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((ReaderState -> Bool)
-> ReaderT [String] (StateT ReaderState m) Bool)
-> (ReaderState -> Bool)
-> ReaderT [String] (StateT ReaderState m) Bool
forall a b. (a -> b) -> a -> b
$ Maybe FileModule -> Bool
forall a. Maybe a -> Bool
isJust (Maybe FileModule -> Bool)
-> (ReaderState -> Maybe FileModule) -> ReaderState -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Imports -> Maybe FileModule
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup (ImportName -> String
includeToString ImportName
include) (Imports -> Maybe FileModule)
-> (ReaderState -> Imports) -> ReaderState -> Maybe FileModule
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderState -> Imports
alreadyImported
Bool -> CompilerM m () -> CompilerM m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
already_done (CompilerM m () -> CompilerM m ())
-> CompilerM m () -> CompilerM m ()
forall a b. (a -> b) -> a -> b
$
(Text -> String -> CompilerM m ())
-> (Text, String) -> CompilerM m ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ([ImportName] -> ImportName -> Text -> String -> CompilerM m ()
forall (m :: * -> *).
(MonadIO m, MonadError CompilerError m) =>
[ImportName] -> ImportName -> Text -> String -> CompilerM m ()
handleFile [ImportName]
steps ImportName
include) ((Text, String) -> CompilerM m ())
-> ReaderT [String] (StateT ReaderState m) (Text, String)
-> CompilerM m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ImportName
-> ReaderT [String] (StateT ReaderState m) (Text, String)
forall (m :: * -> *).
(MonadError CompilerError m, MonadIO m) =>
ImportName -> m (Text, String)
readImportFile ImportName
include
handleFile ::
(MonadIO m, MonadError CompilerError m) =>
[ImportName] ->
ImportName ->
T.Text ->
FilePath ->
CompilerM m ()
handleFile :: [ImportName] -> ImportName -> Text -> String -> CompilerM m ()
handleFile [ImportName]
steps ImportName
include Text
file_contents String
file_name = do
UncheckedProg
prog <- case String -> Text -> Either ParseError UncheckedProg
parseFuthark String
file_name Text
file_contents of
Left ParseError
err -> String -> ReaderT [String] (StateT ReaderState m) UncheckedProg
forall (m :: * -> *) a. MonadError CompilerError m => String -> m a
externalErrorS (String -> ReaderT [String] (StateT ReaderState m) UncheckedProg)
-> String -> ReaderT [String] (StateT ReaderState m) UncheckedProg
forall a b. (a -> b) -> a -> b
$ ParseError -> String
forall a. Show a => a -> String
show ParseError
err
Right UncheckedProg
prog -> UncheckedProg
-> ReaderT [String] (StateT ReaderState m) UncheckedProg
forall (m :: * -> *) a. Monad m => a -> m a
return UncheckedProg
prog
((String, SrcLoc) -> CompilerM m ())
-> [(String, SrcLoc)] -> CompilerM m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ([ImportName] -> ImportName -> CompilerM m ()
forall (m :: * -> *).
(MonadError CompilerError m, MonadIO m) =>
[ImportName] -> ImportName -> CompilerM m ()
readImport [ImportName]
steps' (ImportName -> CompilerM m ())
-> ((String, SrcLoc) -> ImportName)
-> (String, SrcLoc)
-> CompilerM m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> SrcLoc -> ImportName) -> (String, SrcLoc) -> ImportName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (ImportName -> String -> SrcLoc -> ImportName
mkImportFrom ImportName
include)) ([(String, SrcLoc)] -> CompilerM m ())
-> [(String, SrcLoc)] -> CompilerM m ()
forall a b. (a -> b) -> a -> b
$
UncheckedProg -> [(String, SrcLoc)]
forall (f :: * -> *) vn. ProgBase f vn -> [(String, SrcLoc)]
E.progImports UncheckedProg
prog
Imports
imports <- (ReaderState -> Imports)
-> ReaderT [String] (StateT ReaderState m) Imports
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ReaderState -> Imports
alreadyImported
VNameSource
src <- (ReaderState -> VNameSource)
-> ReaderT [String] (StateT ReaderState m) VNameSource
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ReaderState -> VNameSource
nameSource
[String]
roots <- ReaderT [String] (StateT ReaderState m) [String]
forall r (m :: * -> *). MonadReader r m => m r
ask
case Imports
-> VNameSource
-> ImportName
-> UncheckedProg
-> (Warnings, Either TypeError (FileModule, VNameSource))
E.checkProg Imports
imports VNameSource
src ImportName
include (UncheckedProg
-> (Warnings, Either TypeError (FileModule, VNameSource)))
-> UncheckedProg
-> (Warnings, Either TypeError (FileModule, VNameSource))
forall a b. (a -> b) -> a -> b
$ [String] -> UncheckedProg -> UncheckedProg
prependRoots [String]
roots UncheckedProg
prog of
(Warnings
prog_ws, Left TypeError
err) -> do
Warnings
prev_ws <- (ReaderState -> Warnings)
-> ReaderT [String] (StateT ReaderState m) Warnings
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ReaderState -> Warnings
warnings
let ws :: Warnings
ws = Warnings
prev_ws Warnings -> Warnings -> Warnings
forall a. Semigroup a => a -> a -> a
<> Warnings
prog_ws
Doc -> CompilerM m ()
forall (m :: * -> *) a. MonadError CompilerError m => Doc -> m a
externalError (Doc -> CompilerM m ()) -> Doc -> CompilerM m ()
forall a b. (a -> b) -> a -> b
$
if Warnings -> Bool
anyWarnings Warnings
ws
then Warnings -> Doc
forall a. Pretty a => a -> Doc
ppr (Warnings
prev_ws Warnings -> Warnings -> Warnings
forall a. Semigroup a => a -> a -> a
<> Warnings
ws) Doc -> Doc -> Doc
</> Doc
line Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> TypeError -> Doc
forall a. Pretty a => a -> Doc
ppr TypeError
err
else TypeError -> Doc
forall a. Pretty a => a -> Doc
ppr TypeError
err
(Warnings
ws, Right (FileModule
m, VNameSource
src')) ->
(ReaderState -> ReaderState) -> CompilerM m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ReaderState -> ReaderState) -> CompilerM m ())
-> (ReaderState -> ReaderState) -> CompilerM m ()
forall a b. (a -> b) -> a -> b
$ \ReaderState
s ->
ReaderState
s
{ alreadyImported :: Imports
alreadyImported = (ImportName -> String
includeToString ImportName
include, FileModule
m) (String, FileModule) -> Imports -> Imports
forall a. a -> [a] -> [a]
: Imports
imports,
nameSource :: VNameSource
nameSource = VNameSource
src',
warnings :: Warnings
warnings = ReaderState -> Warnings
warnings ReaderState
s Warnings -> Warnings -> Warnings
forall a. Semigroup a => a -> a -> a
<> Warnings
ws
}
where
steps' :: [ImportName]
steps' = ImportName
include ImportName -> [ImportName] -> [ImportName]
forall a. a -> [a] -> [a]
: [ImportName]
steps
readFileSafely :: String -> IO (Maybe (Either String (String, T.Text)))
readFileSafely :: String -> IO (Maybe (Either String (String, Text)))
readFileSafely String
filepath =
(Either String (String, Text)
-> Maybe (Either String (String, Text))
forall a. a -> Maybe a
Just (Either String (String, Text)
-> Maybe (Either String (String, Text)))
-> (Text -> Either String (String, Text))
-> Text
-> Maybe (Either String (String, Text))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, Text) -> Either String (String, Text)
forall a b. b -> Either a b
Right ((String, Text) -> Either String (String, Text))
-> (Text -> (String, Text)) -> Text -> Either String (String, Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
filepath,) (Text -> Maybe (Either String (String, Text)))
-> IO Text -> IO (Maybe (Either String (String, Text)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> IO Text
T.readFile String
filepath) IO (Maybe (Either String (String, Text)))
-> (IOError -> IO (Maybe (Either String (String, Text))))
-> IO (Maybe (Either String (String, Text)))
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
`catch` IOError -> IO (Maybe (Either String (String, Text)))
forall (m :: * -> *) b.
Monad m =>
IOError -> m (Maybe (Either String b))
couldNotRead
where
couldNotRead :: IOError -> m (Maybe (Either String b))
couldNotRead IOError
e
| IOError -> Bool
isDoesNotExistError IOError
e =
Maybe (Either String b) -> m (Maybe (Either String b))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either String b)
forall a. Maybe a
Nothing
| Bool
otherwise =
Maybe (Either String b) -> m (Maybe (Either String b))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Either String b) -> m (Maybe (Either String b)))
-> Maybe (Either String b) -> m (Maybe (Either String b))
forall a b. (a -> b) -> a -> b
$ Either String b -> Maybe (Either String b)
forall a. a -> Maybe a
Just (Either String b -> Maybe (Either String b))
-> Either String b -> Maybe (Either String b)
forall a b. (a -> b) -> a -> b
$ String -> Either String b
forall a b. a -> Either a b
Left (String -> Either String b) -> String -> Either String b
forall a b. (a -> b) -> a -> b
$ IOError -> String
forall a. Show a => a -> String
show IOError
e
readImportFile ::
(MonadError CompilerError m, MonadIO m) =>
ImportName ->
m (T.Text, FilePath)
readImportFile :: ImportName -> m (Text, String)
readImportFile ImportName
include = do
Maybe (Either String (String, Text))
r <- IO (Maybe (Either String (String, Text)))
-> m (Maybe (Either String (String, Text)))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Either String (String, Text)))
-> m (Maybe (Either String (String, Text))))
-> IO (Maybe (Either String (String, Text)))
-> m (Maybe (Either String (String, Text)))
forall a b. (a -> b) -> a -> b
$ String -> IO (Maybe (Either String (String, Text)))
readFileSafely (String -> IO (Maybe (Either String (String, Text))))
-> String -> IO (Maybe (Either String (String, Text)))
forall a b. (a -> b) -> a -> b
$ ImportName -> String
includeToFilePath ImportName
include
case (Maybe (Either String (String, Text))
r, String -> [(String, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup String
prelude_str [(String, Text)]
prelude) of
(Just (Right (String
filepath, Text
s)), Maybe Text
_) -> (Text, String) -> m (Text, String)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
s, String
filepath)
(Just (Left String
e), Maybe Text
_) -> String -> m (Text, String)
forall (m :: * -> *) a. MonadError CompilerError m => String -> m a
externalErrorS String
e
(Maybe (Either String (String, Text))
Nothing, Just Text
t) -> (Text, String) -> m (Text, String)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
t, String
prelude_str)
(Maybe (Either String (String, Text))
Nothing, Maybe Text
Nothing) -> String -> m (Text, String)
forall (m :: * -> *) a. MonadError CompilerError m => String -> m a
externalErrorS String
not_found
where
prelude_str :: String
prelude_str = String
"/" String -> String -> String
Posix.</> ImportName -> String
includeToString ImportName
include String -> String -> String
Posix.<.> String
"fut"
not_found :: String
not_found =
String
"Error at " String -> String -> String
forall a. [a] -> [a] -> [a]
++ SrcLoc -> String
forall a. Located a => a -> String
E.locStr (ImportName -> SrcLoc
forall a. Located a => a -> SrcLoc
E.srclocOf ImportName
include)
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": could not find import '"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ ImportName -> String
includeToString ImportName
include
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'."
readLibraryWithBasis ::
(MonadError CompilerError m, MonadIO m) =>
Basis ->
[FilePath] ->
m
( E.Warnings,
Imports,
VNameSource
)
readLibraryWithBasis :: Basis -> [String] -> m (Warnings, Imports, VNameSource)
readLibraryWithBasis Basis
builtin [String]
fps = do
(Warnings
_, Imports
imps, VNameSource
src) <-
Basis -> CompilerM m () -> m (Warnings, Imports, VNameSource)
forall (m :: * -> *) a.
Monad m =>
Basis -> CompilerM m a -> m (Warnings, Imports, VNameSource)
runCompilerM Basis
builtin (CompilerM m () -> m (Warnings, Imports, VNameSource))
-> CompilerM m () -> m (Warnings, Imports, VNameSource)
forall a b. (a -> b) -> a -> b
$
[ImportName] -> ImportName -> CompilerM m ()
forall (m :: * -> *).
(MonadError CompilerError m, MonadIO m) =>
[ImportName] -> ImportName -> CompilerM m ()
readImport [] (ImportName -> CompilerM m ()) -> ImportName -> CompilerM m ()
forall a b. (a -> b) -> a -> b
$ String -> ImportName
mkInitialImport String
"/prelude/prelude"
let basis :: Basis
basis = Imports -> VNameSource -> [String] -> Basis
Basis Imports
imps VNameSource
src [String
"/prelude/prelude"]
Basis -> [String] -> m (Warnings, Imports, VNameSource)
forall (m :: * -> *).
(MonadError CompilerError m, MonadIO m) =>
Basis -> [String] -> m (Warnings, Imports, VNameSource)
readLibrary' Basis
basis [String]
fps
readLibrary' ::
(MonadError CompilerError m, MonadIO m) =>
Basis ->
[FilePath] ->
m
( E.Warnings,
Imports,
VNameSource
)
readLibrary' :: Basis -> [String] -> m (Warnings, Imports, VNameSource)
readLibrary' Basis
basis [String]
fps = Basis -> CompilerM m [()] -> m (Warnings, Imports, VNameSource)
forall (m :: * -> *) a.
Monad m =>
Basis -> CompilerM m a -> m (Warnings, Imports, VNameSource)
runCompilerM Basis
basis (CompilerM m [()] -> m (Warnings, Imports, VNameSource))
-> CompilerM m [()] -> m (Warnings, Imports, VNameSource)
forall a b. (a -> b) -> a -> b
$ (String -> ReaderT [String] (StateT ReaderState m) ())
-> [String] -> CompilerM m [()]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> ReaderT [String] (StateT ReaderState m) ()
forall (m :: * -> *).
(MonadIO m, MonadError CompilerError m) =>
String -> ReaderT [String] (StateT ReaderState m) ()
onFile [String]
fps
where
onFile :: String -> ReaderT [String] (StateT ReaderState m) ()
onFile String
fp = do
Maybe (Either String (String, Text))
r <- IO (Maybe (Either String (String, Text)))
-> ReaderT
[String]
(StateT ReaderState m)
(Maybe (Either String (String, Text)))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Either String (String, Text)))
-> ReaderT
[String]
(StateT ReaderState m)
(Maybe (Either String (String, Text))))
-> IO (Maybe (Either String (String, Text)))
-> ReaderT
[String]
(StateT ReaderState m)
(Maybe (Either String (String, Text)))
forall a b. (a -> b) -> a -> b
$ String -> IO (Maybe (Either String (String, Text)))
readFileSafely String
fp
case Maybe (Either String (String, Text))
r of
Just (Right (String
_, Text
fs)) ->
[ImportName]
-> ImportName
-> Text
-> String
-> ReaderT [String] (StateT ReaderState m) ()
forall (m :: * -> *).
(MonadIO m, MonadError CompilerError m) =>
[ImportName] -> ImportName -> Text -> String -> CompilerM m ()
handleFile [] (String -> ImportName
mkInitialImport String
fp_name) Text
fs String
fp
Just (Left String
e) -> String -> ReaderT [String] (StateT ReaderState m) ()
forall (m :: * -> *) a. MonadError CompilerError m => String -> m a
externalErrorS String
e
Maybe (Either String (String, Text))
Nothing -> String -> ReaderT [String] (StateT ReaderState m) ()
forall (m :: * -> *) a. MonadError CompilerError m => String -> m a
externalErrorS (String -> ReaderT [String] (StateT ReaderState m) ())
-> String -> ReaderT [String] (StateT ReaderState m) ()
forall a b. (a -> b) -> a -> b
$ String
fp String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": file not found."
where
(String
fp_name, String
_) = String -> (String, String)
Posix.splitExtension String
fp
readImports ::
(MonadError CompilerError m, MonadIO m) =>
Basis ->
[ImportName] ->
m
( E.Warnings,
Imports,
VNameSource
)
readImports :: Basis -> [ImportName] -> m (Warnings, Imports, VNameSource)
readImports Basis
basis [ImportName]
imps =
Basis -> CompilerM m [()] -> m (Warnings, Imports, VNameSource)
forall (m :: * -> *) a.
Monad m =>
Basis -> CompilerM m a -> m (Warnings, Imports, VNameSource)
runCompilerM Basis
basis (CompilerM m [()] -> m (Warnings, Imports, VNameSource))
-> CompilerM m [()] -> m (Warnings, Imports, VNameSource)
forall a b. (a -> b) -> a -> b
$ (ImportName -> ReaderT [String] (StateT ReaderState m) ())
-> [ImportName] -> CompilerM m [()]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([ImportName]
-> ImportName -> ReaderT [String] (StateT ReaderState m) ()
forall (m :: * -> *).
(MonadError CompilerError m, MonadIO m) =>
[ImportName] -> ImportName -> CompilerM m ()
readImport []) [ImportName]
imps
runCompilerM ::
Monad m =>
Basis ->
CompilerM m a ->
m (E.Warnings, [(String, FileModule)], VNameSource)
runCompilerM :: Basis -> CompilerM m a -> m (Warnings, Imports, VNameSource)
runCompilerM (Basis Imports
imports VNameSource
src [String]
roots) CompilerM m a
m = do
let s :: ReaderState
s = Imports -> VNameSource -> Warnings -> ReaderState
ReaderState (Imports -> Imports
forall a. [a] -> [a]
reverse Imports
imports) VNameSource
src Warnings
forall a. Monoid a => a
mempty
ReaderState
s' <- StateT ReaderState m a -> ReaderState -> m ReaderState
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
execStateT (CompilerM m a -> [String] -> StateT ReaderState m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT CompilerM m a
m [String]
roots) ReaderState
s
(Warnings, Imports, VNameSource)
-> m (Warnings, Imports, VNameSource)
forall (m :: * -> *) a. Monad m => a -> m a
return
( ReaderState -> Warnings
warnings ReaderState
s',
Imports -> Imports
forall a. [a] -> [a]
reverse (Imports -> Imports) -> Imports -> Imports
forall a b. (a -> b) -> a -> b
$ ReaderState -> Imports
alreadyImported ReaderState
s',
ReaderState -> VNameSource
nameSource ReaderState
s'
)
prependRoots :: [FilePath] -> E.UncheckedProg -> E.UncheckedProg
prependRoots :: [String] -> UncheckedProg -> UncheckedProg
prependRoots [String]
roots (E.Prog Maybe DocComment
doc [DecBase NoInfo Name]
ds) =
Maybe DocComment -> [DecBase NoInfo Name] -> UncheckedProg
forall (f :: * -> *) vn.
Maybe DocComment -> [DecBase f vn] -> ProgBase f vn
E.Prog Maybe DocComment
doc ([DecBase NoInfo Name] -> UncheckedProg)
-> [DecBase NoInfo Name] -> UncheckedProg
forall a b. (a -> b) -> a -> b
$ (String -> DecBase NoInfo Name)
-> [String] -> [DecBase NoInfo Name]
forall a b. (a -> b) -> [a] -> [b]
map String -> DecBase NoInfo Name
forall vn. String -> DecBase NoInfo vn
mkImport [String]
roots [DecBase NoInfo Name]
-> [DecBase NoInfo Name] -> [DecBase NoInfo Name]
forall a. [a] -> [a] -> [a]
++ [DecBase NoInfo Name]
ds
where
mkImport :: String -> DecBase NoInfo vn
mkImport String
fp =
DecBase NoInfo vn -> SrcLoc -> DecBase NoInfo vn
forall (f :: * -> *) vn. DecBase f vn -> SrcLoc -> DecBase f vn
E.LocalDec (ModExpBase NoInfo vn -> SrcLoc -> DecBase NoInfo vn
forall (f :: * -> *) vn. ModExpBase f vn -> SrcLoc -> DecBase f vn
E.OpenDec (String -> NoInfo String -> SrcLoc -> ModExpBase NoInfo vn
forall (f :: * -> *) vn.
String -> f String -> SrcLoc -> ModExpBase f vn
E.ModImport String
fp NoInfo String
forall a. NoInfo a
E.NoInfo SrcLoc
forall a. Monoid a => a
mempty) SrcLoc
forall a. Monoid a => a
mempty) SrcLoc
forall a. Monoid a => a
mempty