-----------------------------------------------------------------------------
module HeaderInfo ( getImports
+ , mkPrelImports -- used by the renamer too
, getOptionsFromFile, getOptions
, optionsErrorMsgs,
checkProcessArgsResult ) where
#include "HsVersions.h"
+import RdrName
import HscTypes
import Parser ( parseHeader )
import Lexer
import FastString
-import HsSyn ( ImportDecl(..), HsModule(..) )
-import Module ( ModuleName, moduleName )
-import PrelNames ( gHC_PRIM, mAIN_NAME )
-import StringBuffer ( StringBuffer(..), hGetStringBufferBlock
- , appendStringBuffers )
+import HsSyn
+import Module
+import PrelNames
+import StringBuffer
import SrcLoc
import DynFlags
import ErrUtils
import Exception
import Control.Monad
import System.IO
+import System.IO.Unsafe
import Data.List
------------------------------------------------------------------------------
-- reporting parse error locations.
-> FilePath -- ^ The original source filename (used for locations
-- in the function result)
- -> m ([Located ModuleName], [Located ModuleName], Located ModuleName)
+ -> m ([Located (ImportDecl RdrName)], [Located (ImportDecl RdrName)], Located ModuleName)
-- ^ The source imports, normal imports, and the module name.
getImports dflags buf filename source_filename = do
- let loc = mkSrcLoc (mkFastString filename) 1 0
+ let loc = mkSrcLoc (mkFastString filename) 1 1
case unP parseHeader (mkPState buf loc dflags) of
PFailed span err -> parseError span err
POk pst rdr_module -> do
- let ms@(warns, errs) = getMessages pst
- logWarnings warns
+ let _ms@(_warns, errs) = getMessages pst
+ -- don't log warnings: they'll be reported when we parse the file
+ -- for real. See #2500.
+ ms = (emptyBag, errs)
+ -- logWarnings warns
if errorsFound dflags ms
then liftIO $ throwIO $ mkSrcErr errs
else
case rdr_module of
- L _ (HsModule mb_mod _ imps _ _ _ _) ->
+ L _ (HsModule mb_mod _ imps _ _ _) ->
let
- main_loc = mkSrcLoc (mkFastString source_filename) 1 0
+ main_loc = mkSrcLoc (mkFastString source_filename) 1 1
mod = mb_mod `orElse` L (srcLocSpan main_loc) mAIN_NAME
- imps' = filter isHomeImp (map unLoc imps)
- (src_idecls, ord_idecls) = partition isSourceIdecl imps'
- source_imps = map getImpMod src_idecls
- ordinary_imps = filter ((/= moduleName gHC_PRIM) . unLoc)
- (map getImpMod ord_idecls)
+ (src_idecls, ord_idecls) = partition (ideclSource.unLoc) imps
+
-- GHC.Prim doesn't exist physically, so don't go looking for it.
+ ordinary_imps = filter ((/= moduleName gHC_PRIM) . unLoc . ideclName . unLoc)
+ ord_idecls
+
+ implicit_prelude = dopt Opt_ImplicitPrelude dflags
+ implicit_imports = mkPrelImports (unLoc mod) implicit_prelude imps
in
- return (source_imps, ordinary_imps, mod)
-
-parseError :: GhcMonad m => SrcSpan -> Message -> m a
-parseError span err = throwOneError $ mkPlainErrMsg span err
+ return (src_idecls, implicit_imports ++ ordinary_imps, mod)
--- we aren't interested in package imports here, filter them out
-isHomeImp :: ImportDecl name -> Bool
-isHomeImp (ImportDecl _ (Just p) _ _ _ _) = p == fsLit "this"
-isHomeImp (ImportDecl _ Nothing _ _ _ _) = True
+mkPrelImports :: ModuleName -> Bool -> [LImportDecl RdrName]
+ -> [LImportDecl RdrName]
+-- Consruct the implicit declaration "import Prelude" (or not)
+--
+-- NB: opt_NoImplicitPrelude is slightly different to import Prelude ();
+-- because the former doesn't even look at Prelude.hi for instance
+-- declarations, whereas the latter does.
+mkPrelImports this_mod implicit_prelude import_decls
+ | this_mod == pRELUDE_NAME
+ || explicit_prelude_import
+ || not implicit_prelude
+ = []
+ | otherwise = [preludeImportDecl]
+ where
+ explicit_prelude_import
+ = notNull [ () | L _ (ImportDecl mod Nothing _ _ _ _) <- import_decls,
+ unLoc mod == pRELUDE_NAME ]
-isSourceIdecl :: ImportDecl name -> Bool
-isSourceIdecl (ImportDecl _ _ s _ _ _) = s
+ preludeImportDecl :: LImportDecl RdrName
+ preludeImportDecl
+ = L loc $
+ ImportDecl (L loc pRELUDE_NAME)
+ Nothing {- no specific package -}
+ False {- Not a boot interface -}
+ False {- Not qualified -}
+ Nothing {- No "as" -}
+ Nothing {- No import list -}
-getImpMod :: ImportDecl name -> Located ModuleName
-getImpMod (ImportDecl located_mod _ _ _ _ _) = located_mod
+ loc = mkGeneralSrcSpan (fsLit "Implicit import declaration")
+
+parseError :: GhcMonad m => SrcSpan -> Message -> m a
+parseError span err = throwOneError $ mkPlainErrMsg span err
--------------------------------------------------------------
-- Get options
--------------------------------------------------------------
-
+-- | Parse OPTIONS and LANGUAGE pragmas of the source file.
+--
+-- Throws a 'SourceError' if flag parsing fails (including unsupported flags.)
getOptionsFromFile :: DynFlags
- -> FilePath -- input file
- -> IO [Located String] -- options, if any
+ -> FilePath -- ^ Input file
+ -> IO [Located String] -- ^ Parsed options, if any.
getOptionsFromFile dflags filename
= Exception.bracket
(openBinaryFile filename ReadMode)
(hClose)
- (\handle ->
- do buf <- hGetStringBufferBlock handle blockSize
- loop handle buf)
- where blockSize = 1024
- loop handle buf
- | len buf == 0 = return []
- | otherwise
- = case getOptions' dflags buf filename of
- (Nothing, opts) -> return opts
- (Just buf', opts) -> do nextBlock <- hGetStringBufferBlock handle blockSize
- newBuf <- appendStringBuffers buf' nextBlock
- if len newBuf == len buf
- then return opts
- else do opts' <- loop handle newBuf
- return (opts++opts')
-
-getOptions :: DynFlags -> StringBuffer -> FilePath -> [Located String]
+ (\handle -> do
+ opts <- fmap getOptions' $ lazyGetToks dflags filename handle
+ seqList opts $ return opts)
+
+blockSize :: Int
+-- blockSize = 17 -- for testing :-)
+blockSize = 1024
+
+lazyGetToks :: DynFlags -> FilePath -> Handle -> IO [Located Token]
+lazyGetToks dflags filename handle = do
+ buf <- hGetStringBufferBlock handle blockSize
+ unsafeInterleaveIO $ lazyLexBuf handle (pragState dflags buf loc) False
+ where
+ loc = mkSrcLoc (mkFastString filename) 1 1
+
+ lazyLexBuf :: Handle -> PState -> Bool -> IO [Located Token]
+ lazyLexBuf handle state eof = do
+ case unP (lexer return) state of
+ POk state' t -> do
+ -- pprTrace "lazyLexBuf" (text (show (buffer state'))) (return ())
+ if atEnd (buffer state') && not eof
+ -- if this token reached the end of the buffer, and we haven't
+ -- necessarily read up to the end of the file, then the token might
+ -- be truncated, so read some more of the file and lex it again.
+ then getMore handle state
+ else case t of
+ L _ ITeof -> return [t]
+ _other -> do rest <- lazyLexBuf handle state' eof
+ return (t : rest)
+ _ | not eof -> getMore handle state
+ | otherwise -> return [L (last_loc state) ITeof]
+ -- parser assumes an ITeof sentinel at the end
+
+ getMore :: Handle -> PState -> IO [Located Token]
+ getMore handle state = do
+ -- pprTrace "getMore" (text (show (buffer state))) (return ())
+ nextbuf <- hGetStringBufferBlock handle blockSize
+ if (len nextbuf == 0) then lazyLexBuf handle state True else do
+ newbuf <- appendStringBuffers (buffer state) nextbuf
+ unsafeInterleaveIO $ lazyLexBuf handle state{buffer=newbuf} False
+
+
+getToks :: DynFlags -> FilePath -> StringBuffer -> [Located Token]
+getToks dflags filename buf = lexAll (pragState dflags buf loc)
+ where
+ loc = mkSrcLoc (mkFastString filename) 1 1
+
+ lexAll state = case unP (lexer return) state of
+ POk _ t@(L _ ITeof) -> [t]
+ POk state' t -> t : lexAll state'
+ _ -> [L (last_loc state) ITeof]
+
+
+-- | Parse OPTIONS and LANGUAGE pragmas of the source file.
+--
+-- Throws a 'SourceError' if flag parsing fails (including unsupported flags.)
+getOptions :: DynFlags
+ -> StringBuffer -- ^ Input Buffer
+ -> FilePath -- ^ Source filename. Used for location info.
+ -> [Located String] -- ^ Parsed options.
getOptions dflags buf filename
- = case getOptions' dflags buf filename of
- (_,opts) -> opts
+ = getOptions' (getToks dflags filename buf)
-- The token parser is written manually because Happy can't
-- return a partial result when it encounters a lexer error.
-- We want to extract options before the buffer is passed through
-- CPP, so we can't use the same trick as 'getImports'.
-getOptions' :: DynFlags
- -> StringBuffer -- Input buffer
- -> FilePath -- Source file. Used for msgs only.
- -> ( Maybe StringBuffer -- Just => we can use more input
- , [Located String] -- Options.
- )
-getOptions' dflags buf filename
- = parseToks (lexAll (pragState dflags buf loc))
- where loc = mkSrcLoc (mkFastString filename) 1 0
-
- getToken (_buf,L _loc tok) = tok
- getLoc (_buf,L loc _tok) = loc
- getBuf (buf,_tok) = buf
- combine opts (flag, opts') = (flag, opts++opts')
- add opt (flag, opts) = (flag, opt:opts)
+getOptions' :: [Located Token] -- Input buffer
+ -> [Located String] -- Options.
+getOptions' toks
+ = parseToks toks
+ where
+ getToken (L _loc tok) = tok
+ getLoc (L loc _tok) = loc
parseToks (open:close:xs)
| IToptions_prag str <- getToken open
, ITclose_prag <- getToken close
- = map (L (getLoc open)) (words str) `combine`
+ = map (L (getLoc open)) (words str) ++
parseToks xs
parseToks (open:close:xs)
| ITinclude_prag str <- getToken open
, ITclose_prag <- getToken close
- = map (L (getLoc open)) ["-#include",removeSpaces str] `combine`
+ = map (L (getLoc open)) ["-#include",removeSpaces str] ++
parseToks xs
parseToks (open:close:xs)
| ITdocOptions str <- getToken open
, ITclose_prag <- getToken close
= map (L (getLoc open)) ["-haddock-opts", removeSpaces str]
- `combine` parseToks xs
+ ++ parseToks xs
parseToks (open:xs)
| ITdocOptionsOld str <- getToken open
= map (L (getLoc open)) ["-haddock-opts", removeSpaces str]
- `combine` parseToks xs
+ ++ parseToks xs
parseToks (open:xs)
| ITlanguage_prag <- getToken open
= parseLanguage xs
- -- The last token before EOF could have been truncated.
- -- We ignore it to be on the safe side.
- parseToks [tok,eof]
- | ITeof <- getToken eof
- = (Just (getBuf tok),[])
- parseToks (eof:_)
- | ITeof <- getToken eof
- = (Just (getBuf eof),[])
- parseToks _ = (Nothing,[])
- parseLanguage ((_buf,L loc (ITconid fs)):rest)
- = checkExtension (L loc fs) `add`
+ parseToks _ = []
+ parseLanguage (L loc (ITconid fs):rest)
+ = checkExtension (L loc fs) :
case rest of
- (_,L _loc ITcomma):more -> parseLanguage more
- (_,L _loc ITclose_prag):more -> parseToks more
- (_,L loc _):_ -> languagePragParseError loc
+ (L _loc ITcomma):more -> parseLanguage more
+ (L _loc ITclose_prag):more -> parseToks more
+ (L loc _):_ -> languagePragParseError loc
[] -> panic "getOptions'.parseLanguage(1) went past eof token"
parseLanguage (tok:_)
= languagePragParseError (getLoc tok)
parseLanguage []
= panic "getOptions'.parseLanguage(2) went past eof token"
- lexToken t = return t
- lexAll state = case unP (lexer lexToken) state of
- POk _ t@(L _ ITeof) -> [(buffer state,t)]
- POk state' t -> (buffer state,t):lexAll state'
- _ -> [(buffer state,L (last_loc state) ITeof)]
-----------------------------------------------------------------------------
--- Complain about non-dynamic flags in OPTIONS pragmas
+-- | Complain about non-dynamic flags in OPTIONS pragmas.
+--
+-- Throws a 'SourceError' if the input list is non-empty claiming that the
+-- input flags are unknown.
checkProcessArgsResult :: MonadIO m => [Located String] -> m ()
checkProcessArgsResult flags
= when (notNull flags) $
-- its corresponding flag. Otherwise it throws an exception.
= let ext' = unpackFS ext in
if ext' `elem` supportedLanguages
- || ext' `elem` (map ("No"++) supportedLanguages)
then L l ("-X"++ext')
else unsupportedExtnError l ext'
languagePragParseError loc =
throw $ mkSrcErr $ unitBag $
(mkPlainErrMsg loc $
- text "cannot parse LANGUAGE pragma: comma-separated list expected")
+ vcat [ text "Cannot parse LANGUAGE pragma"
+ , text "Expecting comma-separated list of language options,"
+ , text "each starting with a capital letter"
+ , nest 2 (text "E.g. {-# LANGUAGE RecordPuns, Generics #-}") ])
unsupportedExtnError :: SrcSpan -> String -> a
unsupportedExtnError loc unsup =
throw $ mkSrcErr $ unitBag $
mkPlainErrMsg loc $
- text "unsupported extension: " <> text unsup
+ text "Unsupported extension: " <> text unsup $$
+ if null suggestions then empty else text "Perhaps you meant" <+> quotedListWithOr (map text suggestions)
+ where suggestions = fuzzyMatch unsup supportedLanguages
optionsErrorMsgs :: [String] -> [Located String] -> FilePath -> Messages