9525739 · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

Separate compilation for psci, provide output directory option in psc-mkae

commit952573951f79482021b7f54a79de19289ef29d07 authorPhil Freeman <paf31@cantab.net> dateFri 11 Apr 2014, 18:44 (13 years ago) parent51eced9

6 files changed+149−90

compare with golang

unifiedsplit

psc-make/Main.hs+10−9 psc/Main.hs+2−1 psci/Main.hs+101−47 src/Language/PureScript.hs+31−28 src/Language/PureScript/CodeGen/JS.hs+3−3 src/Language/PureScript/Options.hs+2−2

psc-make/Main.hs+10−9

@@ -67,16 +67,17 @@ instance P.MonadMake Make where

6767 U.putStrLn $ "Writing " ++ path

6868 U.writeFile path text

6969 liftError = either throwError return

70+ progress = makeIO . U.putStrLn

7071

71−compile :: P.Options -> [FilePath] -> IO ()

72−compile opts input = do

72+compile :: FilePath -> P.Options -> [FilePath] -> IO ()

73+compile outputDir opts input = do

7374 modules <- readInput input

7475 case modules of

7576 Left err -> do

7677 U.print err

7778 exitFailure

7879 Right ms -> do

79− e <- runMake $ P.make opts ms

80+ e <- runMake $ P.make outputDir opts ms

8081 case e of

8182 Left err -> do

8283 U.putStrLn err

@@ -91,6 +92,10 @@ inputFiles :: Term [FilePath]

9192inputFiles = value $ posAny [] $ posInfo

9293 { posDoc = "The input .ps files" }

9394

95+outputDirectory :: Term FilePath

96+outputDirectory = value $ opt "output" $ (optInfo [ "o", "output" ])

97+ { optDoc = "The output directory" }

98+

9499noTco :: Term Bool

95100noTco = value $ flag $ (optInfo [ "no-tco" ])

96101 { optDoc = "Disable tail call optimizations" }

@@ -111,16 +116,12 @@ noOpts :: Term Bool

111116noOpts = value $ flag $ (optInfo [ "no-opts" ])

112117 { optDoc = "Skip the optimization phase." }

113118

114−browserNamespace :: Term String

115−browserNamespace = value $ opt "PS" $ (optInfo [ "browser-namespace" ])

116− { optDoc = "Specify the namespace that PureScript modules will be exported to when running in the browser." }

117−

118119verboseErrors :: Term Bool

119120verboseErrors = value $ flag $ (optInfo [ "v", "verbose-errors" ])

120121 { optDoc = "Display verbose error messages" }

121122

122123options :: Term P.Options

123−options = P.Options <$> noPrelude <*> noTco <*> performRuntimeTypeChecks <*> noMagicDo <*> pure Nothing <*> noOpts <*> browserNamespace <*> pure [] <*> pure [] <*> verboseErrors

124+options = P.Options <$> noPrelude <*> noTco <*> performRuntimeTypeChecks <*> noMagicDo <*> pure Nothing <*> noOpts <*> pure Nothing <*> pure [] <*> pure [] <*> verboseErrors

124125

125126inputFilesAndPrelude :: FilePath -> Term [FilePath]

126127inputFilesAndPrelude prelude = combine <$> (not <$> noPrelude) <*> inputFiles

@@ -129,7 +130,7 @@ inputFilesAndPrelude prelude = combine <$> (not <$> noPrelude) <*> inputFiles

129130 combine False input = input

130131

131132term :: FilePath -> Term (IO ())

132−term prelude = compile <$> options <*> inputFilesAndPrelude prelude

133+term prelude = compile <$> outputDirectory <*> options <*> inputFilesAndPrelude prelude

133134

134135termInfo :: TermInfo

135136termInfo = defTI

psc/Main.hs+2−1

@@ -127,7 +127,7 @@ verboseErrors = value $ flag $ (optInfo [ "v", "verbose-errors" ])

127127 { optDoc = "Display verbose error messages" }

128128

129129options :: Term P.Options

130−options = P.Options <$> noPrelude <*> noTco <*> performRuntimeTypeChecks <*> noMagicDo <*> runMain <*> noOpts <*> browserNamespace <*> dceModules <*> codeGenModules <*> verboseErrors

130+options = P.Options <$> noPrelude <*> noTco <*> performRuntimeTypeChecks <*> noMagicDo <*> runMain <*> noOpts <*> (Just <$> browserNamespace) <*> dceModules <*> codeGenModules <*> verboseErrors

131131

132132stdInOrInputFiles :: FilePath -> Term (Maybe [FilePath])

133133stdInOrInputFiles prelude = combine <$> useStdIn <*> (not <$> noPrelude) <*> inputFiles

@@ -150,3 +150,4 @@ main :: IO ()

150150main = do

151151 prelude <- preludeFilename

152152 run (term prelude, termInfo)

153+

psci/Main.hs+101−47

@@ -13,7 +13,7 @@

1313--

1414-----------------------------------------------------------------------------

1515

16−{-# LANGUAGE DoAndIfThenElse, FlexibleContexts #-}

16+{-# LANGUAGE DoAndIfThenElse, FlexibleContexts, GeneralizedNewtypeDeriving #-}

1717

1818module Main where

1919

@@ -24,29 +24,36 @@ import Control.Monad

2424import Control.Monad.Trans.Class

2525import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)

2626import Control.Monad.Trans.State.Strict

27+import Control.Monad.Error (ErrorT(..), MonadError)

28+import Control.Monad.Error.Class (MonadError(..))

2729

2830import Data.List (intercalate, isPrefixOf, nub, sortBy)

2931import Data.Maybe (mapMaybe)

3032import Data.Foldable (traverse_)

31−import Data.Traversable (traverse)

3233import Data.Version (showVersion)

34+import Data.Traversable (traverse)

3335

3436import Parser

3537

38+import System.IO.Error (tryIOError)

3639import System.Console.Haskeline

37−import System.Directory (doesFileExist, findExecutable, getHomeDirectory, getCurrentDirectory)

40+import System.Directory

41+ (createDirectoryIfMissing, getModificationTime, doesFileExist,

42+ findExecutable, getHomeDirectory, getCurrentDirectory)

43+import System.Process (readProcessWithExitCode)

3844import System.Exit

3945import System.Environment.XDG.BaseDir

40−import System.FilePath ((</>), isPathSeparator)

46+import System.FilePath

47+ (pathSeparator, takeDirectory, (</>), isPathSeparator)

4148import qualified System.Console.CmdTheLine as Cmd

42−import System.Process

4349

4450import Text.Parsec (ParseError)

4551

4652import qualified Data.Map as M

4753import qualified Language.PureScript as P

4854import qualified Paths_purescript as Paths

49−import qualified System.IO.UTF8 as U (print, readFile)

55+import qualified System.IO.UTF8 as U

56+ (writeFile, putStrLn, print, readFile)

5057

5158-- |

5259-- The PSCI state.

@@ -57,7 +64,7 @@ import qualified System.IO.UTF8 as U (print, readFile)

5764data PSCiState = PSCiState

5865 { psciImportedFilenames :: [FilePath]

5966 , psciImportedModuleNames :: [P.ModuleName]

60− , psciLoadedModules :: [P.Module]

67+ , psciLoadedModules :: [(FilePath, P.Module)]

6168 , psciLetBindings :: [P.Value -> P.Value]

6269 }

6370

@@ -78,7 +85,7 @@ updateImports name st = st { psciImportedModuleNames = name : psciImportedModule

7885-- |

7986-- Updates the state to have more loaded files.

8087--

81−updateModules :: [P.Module] -> PSCiState -> PSCiState

88+updateModules :: [(FilePath, P.Module)] -> PSCiState -> PSCiState

8289updateModules modules st = st { psciLoadedModules = psciLoadedModules st ++ modules }

8390

8491-- |

@@ -168,7 +175,7 @@ completion = completeWord Nothing " \t\n\r" findCompletions

168175 where

169176 findCompletions :: String -> StateT PSCiState IO [Completion]

170177 findCompletions str = do

171− ms <- psciLoadedModules <$> get

178+ ms <- map snd . psciLoadedModules <$> get

172179 files <- listFiles str

173180 let matches = filter (isPrefixOf str) (names ms)

174181 return $ sortBy sorter $ map simpleCompletion matches ++ files

@@ -197,7 +204,39 @@ completion = completeWord Nothing " \t\n\r" findCompletions

197204-- | Compilation options.

198205--

199206options :: P.Options

200−options = P.Options False True False True (Just "Main") True "PS" [] [] False

207+options = P.Options False True False True Nothing True (Just "PS") [] [] False

208+

209+-- |

210+-- PSCI monad

211+--

212+newtype PSCI a = PSCI { runPSCI :: InputT (StateT PSCiState IO) a } deriving (Functor, Applicative, Monad)

213+

214+psciIO :: IO a -> PSCI a

215+psciIO io = PSCI (lift (lift io))

216+

217+newtype Make a = Make { unMake :: ErrorT String IO a } deriving (Functor, Applicative, Monad, MonadError String)

218+

219+runMake :: Make a -> IO (Either String a)

220+runMake = runErrorT . unMake

221+

222+makeIO :: IO a -> Make a

223+makeIO = Make . ErrorT . fmap (either (Left . show) Right) . tryIOError

224+

225+instance P.MonadMake Make where

226+ getTimestamp path = makeIO $ do

227+ exists <- doesFileExist path

228+ case exists of

229+ True -> Just <$> getModificationTime path

230+ False -> return Nothing

231+ readTextFile path = makeIO $ U.readFile path

232+ writeTextFile path text = makeIO $ do

233+ mkdirp path

234+ U.writeFile path text

235+ liftError = either throwError return

236+ progress s = unless (s == "Compiling Main") $ makeIO . U.putStrLn $ s

237+

238+mkdirp :: FilePath -> IO ()

239+mkdirp = createDirectoryIfMissing True . takeDirectory

201240

202241-- |

203242-- Makes a volatile module to execute the current expression.

@@ -217,34 +256,45 @@ createTemporaryModule exec PSCiState{psciImportedModuleNames = imports, psciLetB

217256 in

218257 P.Module moduleName ((importDecl `map` imports) ++ decls) Nothing

219258

259+modulesDir :: FilePath

260+modulesDir = "psci_modules" ++ pathSeparator : "node_modules"

261+

262+indexFile :: FilePath

263+indexFile = "psci_modules" ++ pathSeparator : "index.js"

264+

220265-- |

221266-- Takes a value declaration and evaluates it with the current state.

222267--

223−handleDeclaration :: P.Value -> PSCiState -> InputT (StateT PSCiState IO) ()

224−handleDeclaration value st = do

268+handleDeclaration :: P.Value -> PSCI ()

269+handleDeclaration value = do

270+ st <- PSCI $ lift get

225271 let m = createTemporaryModule True st value

226− case P.compile options (psciLoadedModules st ++ [m]) of

227− Left err -> outputStrLn err

228− Right (js, _, _) -> do

229− process <- lift . lift $ findNodeProcess

230− result <- lift . lift $ traverse (\node -> readProcessWithExitCode node [] js) process

272+ e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [("Main.purs", m)])

273+ case e of

274+ Left err -> PSCI $ outputStrLn err

275+ Right _ -> do

276+ psciIO $ writeFile indexFile $ "require('Main').main();"

277+ process <- psciIO findNodeProcess

278+ result <- psciIO $ traverse (\node -> readProcessWithExitCode node [indexFile] "") process

231279 case result of

232− Just (ExitSuccess, out, _) -> outputStrLn out

233− Just (ExitFailure _, _, err) -> outputStrLn err

234− Nothing -> outputStrLn "Couldn't find node.js"

280+ Just (ExitSuccess, out, _) -> PSCI $ outputStrLn out

281+ Just (ExitFailure _, _, err) -> PSCI $ outputStrLn err

282+ Nothing -> PSCI $ outputStrLn "Couldn't find node.js"

235283

236284-- |

237285-- Takes a value and prints its type

238286--

239−handleTypeOf :: P.Value -> PSCiState -> InputT (StateT PSCiState IO) ()

240−handleTypeOf value st = do

287+handleTypeOf :: P.Value -> PSCI ()

288+handleTypeOf value = do

289+ st <- PSCI $ lift get

241290 let m = createTemporaryModule False st value

242− case P.compile options { P.optionsMain = Nothing } (psciLoadedModules st ++ [m]) of

243− Left err -> outputStrLn err

244− Right (_, _, env') ->

291+ e <- psciIO . runMake $ P.make modulesDir options (psciLoadedModules st ++ [("Main.purs", m)])

292+ case e of

293+ Left err -> PSCI $ outputStrLn err

294+ Right env' ->

245295 case M.lookup (P.ModuleName [P.ProperName "Main"], P.Ident "it") (P.names env') of

246− Just (ty, _) -> outputStrLn . P.prettyPrintType $ ty

247− Nothing -> outputStrLn "Could not find type"

296+ Just (ty, _) -> PSCI . outputStrLn . P.prettyPrintType $ ty

297+ Nothing -> PSCI $ outputStrLn "Could not find type"

248298

249299-- Commands

250300

@@ -265,27 +315,31 @@ getCommand = do

265315-- |

266316-- Performs an action for each meta-command given, and also for expressions..

267317--

268−handleCommand :: Command -> InputT (StateT PSCiState IO) ()

269−handleCommand (Expression val) = lift get >>= handleDeclaration val

270−handleCommand Help = outputStrLn helpMessage

271−handleCommand (Import moduleName) = lift $ modify (updateImports moduleName)

272−handleCommand (Let l) = lift $ modify (updateLets l)

318+handleCommand :: Command -> PSCI ()

319+handleCommand (Expression val) = handleDeclaration val

320+handleCommand Help = PSCI $ outputStrLn helpMessage

321+handleCommand (Import moduleName) = PSCI $ lift $ modify (updateImports moduleName)

322+handleCommand (Let l) = PSCI $ lift $ modify (updateLets l)

273323handleCommand (LoadFile filePath) = do

274− absPath <- lift . lift $ expandTilde filePath

275− exists <- lift . lift $ doesFileExist absPath

324+ absPath <- psciIO $ expandTilde filePath

325+ exists <- psciIO $ doesFileExist absPath

276326 if exists then do

277− lift $ modify (updateImportedFiles absPath)

278− either outputStrLn (lift . modify . updateModules) =<< (lift . lift $ loadModule absPath)

327+ PSCI . lift $ modify (updateImportedFiles absPath)

328+ m <- psciIO $ loadModule absPath

329+ case m of

330+ Left err -> PSCI $ outputStrLn err

331+ Right mods -> PSCI . lift $ modify (updateModules (map ((,) absPath) mods))

279332 else

280− outputStrLn $ "Couldn't locate: " ++ filePath

333+ PSCI . outputStrLn $ "Couldn't locate: " ++ filePath

281334handleCommand Reset = do

282− files <- psciImportedFilenames <$> lift get

283− modulesOrFirstError <- fmap concat . sequence <$> mapM (lift . lift . loadModule) files

335+ files <- psciImportedFilenames <$> PSCI (lift get)

336+ filesAndModules <- mapM (\file -> fmap (fmap (map ((,) file))) . psciIO . loadModule $ file) files

337+ let modulesOrFirstError = fmap concat $ sequence filesAndModules

284338 case modulesOrFirstError of

285− Left err -> lift . lift $ putStrLn err >> exitFailure

286− Right modules -> lift $ put (PSCiState files defaultImports modules [])

287−handleCommand (TypeOf val) = lift get >>= handleTypeOf val

288−handleCommand _ = outputStrLn "Unknown command"

339+ Left err -> psciIO $ putStrLn err >> exitFailure

340+ Right modules -> PSCI . lift $ put (PSCiState files defaultImports modules [])

341+handleCommand (TypeOf val) = handleTypeOf val

342+handleCommand _ = PSCI $ outputStrLn "Unknown command"

289343

290344inputFiles :: Cmd.Term [FilePath]

291345inputFiles = Cmd.value $ Cmd.posAny [] $ Cmd.posInfo { Cmd.posName = "file(s)"

@@ -311,7 +365,8 @@ loop :: [FilePath] -> IO ()

311365loop files = do

312366 config <- loadUserConfig

313367 preludeFilename <- getPreludeFilename

314− modulesOrFirstError <- fmap concat . sequence <$> mapM loadModule (preludeFilename : files)

368+ filesAndModules <- mapM (\file -> fmap (fmap (map ((,) file))) . loadModule $ file) (preludeFilename : files)

369+ let modulesOrFirstError = fmap concat $ sequence filesAndModules

315370 case modulesOrFirstError of

316371 Left err -> putStrLn err >> exitFailure

317372 Right modules -> do

@@ -319,7 +374,7 @@ loop files = do

319374 let settings = defaultSettings {historyFile = Just historyFilename}

320375 flip evalStateT (PSCiState (preludeFilename : files) defaultImports modules []) . runInputT (setComplete completion settings) $ do

321376 outputStrLn prologueMessage

322− traverse_ (mapM_ handleCommand) config

377+ traverse_ (mapM_ (runPSCI . handleCommand)) config

323378 go

324379 where

325380 go :: InputT (StateT PSCiState IO) ()

@@ -329,7 +384,7 @@ loop files = do

329384 Left err -> outputStrLn (show err) >> go

330385 Right Nothing -> go

331386 Right (Just Quit) -> outputStrLn quitMessage

332− Right (Just c') -> handleCommand c' >> go

387+ Right (Just c') -> runPSCI (handleCommand c') >> go

333388

334389term :: Cmd.Term (IO ())

335390term = loop <$> inputFiles

@@ -343,4 +398,3 @@ termInfo = Cmd.defTI

343398

344399main :: IO ()

345400main = Cmd.run (term, termInfo)

346−

src/Language/PureScript.hs+31−28

@@ -37,7 +37,7 @@ import Data.List (find, sortBy, groupBy, intercalate)

3737import Data.Time.Clock

3838import Data.Function (on)

3939import Data.Generics (mkQ, everything)

40−import Data.Maybe (fromMaybe)

40+import Data.Maybe (fromJust, fromMaybe)

4141import Control.Monad.Error

4242import Control.Monad.State.Lazy

4343import Control.Arrow ((&&&))

@@ -78,7 +78,7 @@ compile' env opts ms = do

7878 let elim = if null entryPoints then regrouped else eliminateDeadCode entryPoints regrouped

7979 let codeGenModules = moduleNameFromString `map` optionsCodeGenModules opts

8080 let modulesToCodeGen = if null codeGenModules then elim else filter (\(Module mn _ _) -> mn `elem` codeGenModules) elim

81− let js = JSVariableIntroduction (optionsBrowserNamespace opts) (Just (JSObjectLiteral []))

81+ let js = JSVariableIntroduction (fromJust (optionsBrowserNamespace opts)) (Just (JSObjectLiteral []))

8282 : concatMap (\m -> moduleToJs Globals opts m env') modulesToCodeGen

8383 let exts = intercalate "\n" . map (`moduleToPs` env') $ modulesToCodeGen

8484 js' <- generateMain env' opts js

@@ -156,6 +156,10 @@ class MonadMake m where

156156 --

157157 liftError :: Either String a -> m a

158158

159+ -- |

160+ -- Respond to a progress update

161+ --

162+ progress :: String -> m ()

159163

160164-- |

161165-- Compiles in "make" mode, compiling each module separately to a js files and an externs file

@@ -163,17 +167,17 @@ class MonadMake m where

163167-- If timestamps have not changed, the externs file can be used to provide the module's types without

164168-- having to typecheck the module again.

165169--

166−make :: (Functor m, Monad m, MonadMake m) => Options -> [(FilePath, Module)] -> m ()

167−make opts ms = do

170+make :: (Functor m, Monad m, MonadMake m) => FilePath -> Options -> [(FilePath, Module)] -> m Environment

171+make outputDir opts ms = do

168172 let filePathMap = M.fromList (map (\(fp, Module mn _ _) -> (mn, fp)) ms)

169173

170174 (sorted, graph) <- liftError $ sortModules $ if optionsNoPrelude opts then map snd ms else (map (importPrelude . snd) ms)

171175

172176 toRebuild <- foldM (\s (Module moduleName' _ _) -> do

173− let filePath = toFileName moduleName'

177+ let filePath = runModuleName moduleName'

174178

175− jsFile = "js" ++ pathSeparator : filePath ++ ".js"

176− externsFile = "externs" ++ pathSeparator : filePath ++ ".externs"

179+ jsFile = outputDir ++ pathSeparator : filePath ++ pathSeparator : "index.js"

180+ externsFile = outputDir ++ pathSeparator : filePath ++ pathSeparator : "externs.purs"

177181 inputFile = fromMaybe (error "Input file is undefined in make") $ M.lookup moduleName' filePathMap

178182

179183 jsTimestamp <- getTimestamp jsFile

@@ -191,16 +195,18 @@ make opts ms = do

191195 go initEnvironment desugared

192196

193197 where

194− go :: (Functor m, Monad m, MonadMake m) => Environment -> [(Bool, Module)] -> m ()

195− go _ [] = return ()

198+ go :: (Functor m, Monad m, MonadMake m) => Environment -> [(Bool, Module)] -> m Environment

199+ go env [] = return env

196200 go env ((False, m) : ms') = do

197201 (_, env') <- liftError . runCheck' opts env $ typeCheckModule Nothing m

198202

199203 go env' ms'

200204 go env ((True, m@(Module moduleName' _ exps)) : ms') = do

201− let filePath = toFileName moduleName'

202− jsFile = "js" ++ pathSeparator : filePath ++ ".js"

203− externsFile = "externs" ++ pathSeparator : filePath ++ ".externs"

205+ let filePath = runModuleName moduleName'

206+ jsFile = outputDir ++ pathSeparator : filePath ++ pathSeparator : "index.js"

207+ externsFile = outputDir ++ pathSeparator : filePath ++ pathSeparator : "externs.purs"

208+

209+ progress $ "Compiling " ++ runModuleName moduleName'

204210

205211 (Module _ elaborated _, env') <- liftError . runCheck' opts env $ typeCheckModule Nothing m

206212

@@ -215,22 +221,19 @@ make opts ms = do

215221

216222 go env' ms'

217223

218−toFileName :: ModuleName -> FilePath

219−toFileName (ModuleName ps) = intercalate [pathSeparator] . map runProperName $ ps

220−

221−rebuildIfNecessary :: (Functor m, Monad m, MonadMake m) => M.Map ModuleName [ModuleName] -> S.Set ModuleName -> [Module] -> m [(Bool, Module)]

222−rebuildIfNecessary _ _ [] = return []

223−rebuildIfNecessary graph toRebuild (m@(Module moduleName' _ _) : ms) | moduleName' `S.member` toRebuild = do

224− let deps = fromMaybe [] $ moduleName' `M.lookup` graph

225− toRebuild' = toRebuild `S.union` S.fromList deps

226− (:) (True, m) <$> rebuildIfNecessary graph toRebuild' ms

227−rebuildIfNecessary graph toRebuild (Module moduleName' _ _ : ms) = do

228− let externsFile = "externs" ++ pathSeparator : toFileName moduleName' ++ ".externs"

229− externs <- readTextFile externsFile

230− externsModules <- liftError . either (Left . show) Right $ P.runIndentParser externsFile P.parseModules externs

231− case externsModules of

232− [m'@(Module moduleName'' _ _)] | moduleName'' == moduleName' -> (:) (False, m') <$> rebuildIfNecessary graph toRebuild ms

233− _ -> liftError . Left $ "Externs file " ++ externsFile ++ " was invalid"

224+ rebuildIfNecessary :: (Functor m, Monad m, MonadMake m) => M.Map ModuleName [ModuleName] -> S.Set ModuleName -> [Module] -> m [(Bool, Module)]

225+ rebuildIfNecessary _ _ [] = return []

226+ rebuildIfNecessary graph toRebuild (m@(Module moduleName' _ _) : ms') | moduleName' `S.member` toRebuild = do

227+ let deps = fromMaybe [] $ moduleName' `M.lookup` graph

228+ toRebuild' = toRebuild `S.union` S.fromList deps

229+ (:) (True, m) <$> rebuildIfNecessary graph toRebuild' ms'

230+ rebuildIfNecessary graph toRebuild (Module moduleName' _ _ : ms') = do

231+ let externsFile = outputDir ++ pathSeparator : runModuleName moduleName' ++ pathSeparator : "externs.purs"

232+ externs <- readTextFile externsFile

233+ externsModules <- liftError . either (Left . show) Right $ P.runIndentParser externsFile P.parseModules externs

234+ case externsModules of

235+ [m'@(Module moduleName'' _ _)] | moduleName'' == moduleName' -> (:) (False, m') <$> rebuildIfNecessary graph toRebuild ms'

236+ _ -> liftError . Left $ "Externs file " ++ externsFile ++ " was invalid"

234237

235238reverseDependencies :: ModuleGraph -> M.Map ModuleName [ModuleName]

236239reverseDependencies g = combine [ (dep, mn) | (mn, deps) <- g, dep <- deps ]

src/Language/PureScript/CodeGen/JS.hs+3−3

@@ -23,7 +23,7 @@ module Language.PureScript.CodeGen.JS (

2323 isIdent

2424) where

2525

26−import Data.Maybe (fromMaybe, mapMaybe)

26+import Data.Maybe (fromJust, fromMaybe, mapMaybe)

2727import Data.Function (on)

2828import Data.List (nub, (\\))

2929import Data.Generics (mkQ, everything)

@@ -57,7 +57,7 @@ moduleToJs :: ModuleType -> Options -> Module -> Environment -> [JS]

5757moduleToJs mt opts (Module name decls (Just exps)) env = case mt of

5858 CommonJS -> moduleBody ++ [JSAssignment (JSAccessor "exports" (JSVar "module")) moduleExports]

5959 Globals ->

60− [ JSAssignment (JSAccessor (moduleNameToJs name) (JSVar (optionsBrowserNamespace opts))) (

60+ [ JSAssignment (JSAccessor (moduleNameToJs name) (JSVar (fromJust (optionsBrowserNamespace opts)))) (

6161 JSApp (JSFunction Nothing [] (JSBlock (moduleBody ++ [JSReturn moduleExports]))) []

6262 )

6363 ]

@@ -73,7 +73,7 @@ importToJs mt opts mn = JSVariableIntroduction (moduleNameToJs mn) (Just moduleB

7373 where

7474 moduleBody = case mt of

7575 CommonJS -> JSApp (JSVar "require") [JSStringLiteral (runModuleName mn)]

76− Globals -> JSAccessor (runModuleName mn) (JSVar (optionsBrowserNamespace opts))

76+ Globals -> JSAccessor (runModuleName mn) (JSVar (fromJust (optionsBrowserNamespace opts)))

7777

7878imports :: Declaration -> [ModuleName]

7979imports = everything (++) (mkQ [] collect)

src/Language/PureScript/Options.hs+2−2

@@ -48,7 +48,7 @@ data Options = Options {

4848 -- Specify the namespace that PureScript modules will be exported to when running in the

4949 -- browser.

5050 --

51− , optionsBrowserNamespace :: String

51+ , optionsBrowserNamespace :: Maybe String

5252 -- |

5353 -- The modules to keep while enabling dead code elimination

5454 --

@@ -67,4 +67,4 @@ data Options = Options {

6767-- Default compiler options

6868--

6969defaultOptions :: Options

70−defaultOptions = Options False False False False Nothing False "PS" [] [] False

70+defaultOptions = Options False False False False Nothing False Nothing [] [] False