0 | module TTImp.Elab.RunElab
2 | import Core.Directory
12 | import Idris.Resugar
13 | import Idris.REPL.Opts
17 | import Libraries.Data.List.SizeOf
18 | import Libraries.Data.NameMap
19 | import Libraries.Data.NatSet
20 | import Libraries.Data.WithDefault
21 | import Libraries.Text.PrettyPrint.Prettyprinter.Doc
22 | import Libraries.Utils.Path
24 | import TTImp.Elab.Check
25 | import TTImp.Elab.Delayed
26 | import TTImp.Reflect
28 | import TTImp.TTImp.Functor
31 | import System.File.Meta
35 | record NameInfo where
36 | constructor MkNameInfo
39 | lookupNameInfo : Name -> Context -> Core (List (Name, NameInfo))
40 | lookupNameInfo n ctxt
41 | = do res <- lookupCtxtName n ctxt
42 | pure (map (\ (n, i, gd) =>
43 | (n, MkNameInfo { nametype = getDefNameType gd } ))
46 | Reflect NameInfo where
47 | reflect fc defs lhs env inf
48 | = do nt <- reflect fc defs lhs env (nametype inf)
49 | appCon fc defs (reflectiontt "MkNameInfo") [nt]
51 | deepRefersTo : {auto c : Ref Ctxt Defs} ->
52 | GlobalDef -> Core (List Name)
53 | deepRefersTo def = do
55 | map nub $
clos empty defs $
refs' defs def
58 | refs' : Defs -> GlobalDef -> List Name
59 | refs' defs def = keys (refersTo def)
61 | refs : Defs -> Name -> Core (List Name)
62 | refs defs n = maybe [] (refs' defs) <$> lookupCtxtExact n (gamma defs)
64 | clos : NameMap () -> Defs -> List Name -> Core (List Name)
65 | clos all _ [] = pure (keys all)
66 | clos all defs (n::ns) = case lookup n all of
67 | Just _ => clos all defs ns
69 | let all' = insert n () all
70 | let ns' = !(refs defs n) ++ ns
74 | elabScript : {vars : _} ->
75 | {auto c : Ref Ctxt Defs} ->
76 | {auto m : Ref MD Metadata} ->
77 | {auto u : Ref UST UState} ->
78 | {auto s : Ref Syn SyntaxInfo} ->
79 | {auto o : Ref ROpts REPLOpts} ->
80 | RigCount -> FC -> NestedNames vars ->
81 | Env Term vars -> NF vars -> Maybe (Glued vars) ->
83 | elabScript rig fc nest env script@(NDCon nfc nm t ar args) exp
84 | = do defs <- get Ctxt
85 | fnm <- toFullNames nm
87 | NS ns (UN (Basic n))
88 | => if ns == reflectionNS
89 | then elabCon defs n (map snd args)
91 | e@(BadRunElab {}) => throw e
92 | e@(RunElabFail {}) => throw e
93 | e => throw $
RunElabFail e
94 | else failWith defs $
"bad reflection namespace " ++ show ns
95 | _ => failWith defs $
"bad fullnames " ++ show fnm
97 | failWith : Defs -> String -> Core a
99 | = do empty <- clearDefs defs
100 | throw (BadRunElab fc env !(quote empty env script) desc)
102 | scriptRet : Reflect a => a -> Core (NF vars)
104 | = do defs <- get Ctxt
105 | nfOpts withAll defs env !(reflect fc defs False env tm)
107 | reifyFC : Defs -> Closure vars -> Core FC
108 | reifyFC defs mbfc = pure $
case !(evalClosure defs mbfc >>= reify defs) of
113 | lookupDir : Defs -> NF vars -> Core String
114 | lookupDir defs (NDCon _ conName _ _ [])
115 | = do defs <- get Ctxt
116 | NS ns (UN (Basic n)) <- toFullNames conName
117 | | fnm => failWith defs $
"bad lookup dir fullnames " ++ show fnm
118 | let True = ns == reflectionNS
119 | | False => failWith defs $
"bad lookup dir namespace " ++ show ns
120 | let wd = defs.options.dirs.working_dir
121 | let sd = maybe wd (\sd => joinPath [wd, sd]) defs.options.dirs.source_dir
122 | let modDir : Bool -> Core String := \doParent => do
124 | let parentIfNeeded = if doParent then parent else pure
125 | let moduleSuffix = toList $
(head' syn.saveMod >>= parentIfNeeded) <&> toPath
126 | pure $
joinPath $
sd :: moduleSuffix
128 | "ProjectDir" => pure wd
129 | "SourceDir" => pure sd
130 | "CurrentModuleDir" => modDir True
131 | "SubmodulesDir" => modDir False
132 | "BuildDir" => pure $
joinPath [wd, defs.options.dirs.build_dir]
133 | _ => failWith defs $
"bad lookup dir value"
135 | = do defs <- get Ctxt
136 | empty <- clearDefs defs
137 | throw (BadRunElab fc env !(quote empty env lk) "lookup dir is not a data value")
139 | validatePath : Defs -> String -> Core ()
140 | validatePath defs path = do
141 | let True = isRelative path
142 | | False => failWith defs $
"path must be relative"
143 | let True = pathDoesNotEscape 0 $
splitPath path
144 | | False => failWith defs $
"path must not escape the directory"
147 | pathDoesNotEscape : (depth : Nat) -> List String -> Bool
148 | pathDoesNotEscape _ [] = True
149 | pathDoesNotEscape Z (".."::rest) = False
150 | pathDoesNotEscape (S n) (".."::rest) = pathDoesNotEscape n rest
151 | pathDoesNotEscape n ("." ::rest) = pathDoesNotEscape n rest
152 | pathDoesNotEscape n (_ ::rest) = pathDoesNotEscape (S n) rest
154 | elabCon : Defs -> String -> List (Closure vars) -> Core (NF vars)
155 | elabCon defs "Pure" [_,val]
156 | = do empty <- clearDefs defs
157 | evalClosure empty val
158 | elabCon defs "Map" [_,_,fm,act]
161 | = do act <- elabScript rig fc nest env !(evalClosure defs act) exp
162 | act <- quote defs env act
163 | fm <- evalClosure defs fm
164 | applyToStack defs withHoles env fm [(getLoc act, toClosure withAll env act)]
165 | elabCon defs "Ap" [_,_,actF,actX]
168 | = do actF <- elabScript rig fc nest env !(evalClosure defs actF) exp
169 | actX <- elabScript rig fc nest env !(evalClosure defs actX) exp
170 | actX <- quote defs env actX
171 | applyToStack defs withHoles env actF [(getLoc actX, toClosure withAll env actX)]
172 | elabCon defs "Bind" [_,_,act,k]
179 | = do act <- elabScript rig fc nest env
180 | !(evalClosure defs act) exp
181 | act <- quote defs env act
182 | k <- evalClosure defs k
183 | r <- applyToStack defs withAll env k [(getLoc act, toClosure withAll env act)]
184 | elabScript rig fc nest env r exp
185 | elabCon defs "Fail" [_, mbfc, msg]
186 | = do msg' <- evalClosure defs msg
187 | throw $
RunElabFail $
GenericMsg !(reifyFC defs mbfc) !(reify defs msg')
188 | elabCon defs "Warn" [mbfc, msg]
189 | = do msg' <- evalClosure defs msg
190 | recordWarning $
GenericWarn !(reifyFC defs mbfc) !(reify defs msg')
192 | elabCon defs "Try" [_, elab1, elab2]
193 | = tryUnify (do constart <- getNextEntry
194 | res <- elabScript rig fc nest env !(evalClosure defs elab1) exp
198 | solveConstraintsAfter constart inTerm LastChance
200 | (elabScript rig fc nest env !(evalClosure defs elab2) exp)
201 | elabCon defs "LogMsg" [topic, verb, str]
202 | = do topic' <- evalClosure defs topic
203 | verb' <- evalClosure defs verb
204 | unverifiedLogC !(reify defs topic') !(reify defs verb') $
205 | do str' <- evalClosure defs str
208 | elabCon defs "LogTerm" [topic, verb, str, tm]
209 | = do topic' <- evalClosure defs topic
210 | verb' <- evalClosure defs verb
211 | unverifiedLogC !(reify defs topic') !(reify defs verb') $
212 | do str' <- evalClosure defs str
213 | tm' <- evalClosure defs tm
214 | pure $
!(reify defs str') ++ ": " ++
215 | show (the RawImp !(reify defs tm'))
217 | elabCon defs "LogSugaredTerm" [topic, verb, str, tm]
218 | = do topic' <- evalClosure defs topic
219 | verb' <- evalClosure defs verb
220 | unverifiedLogC !(reify defs topic') !(reify defs verb') $
221 | do str' <- evalClosure defs str
222 | tm' <- reify defs !(evalClosure defs tm)
223 | ptm <- pterm (map defaultKindedName tm')
224 | pure $
!(reify defs str') ++ ": " ++ show ptm
226 | elabCon defs "ResugarTerm" [maxLineWidth, tm]
227 | = do ptm <- pterm . map defaultKindedName =<< reify defs !(evalClosure defs tm)
228 | mlw : Maybe Nat <- reify defs !(evalClosure defs maxLineWidth)
229 | let pw = maybe Unbounded (\w => AvailablePerLine (cast w) 1) mlw
230 | scriptRet $
render' pw Nothing $
pretty {ann=IdrisSyntax} ptm
231 | elabCon defs "Check" [exp, ttimp]
232 | = do exp' <- evalClosure defs exp
233 | ttimp' <- evalClosure defs ttimp
234 | tidx <- resolveName (UN $
Basic "[elaborator script]")
235 | e <- newRef EST (initEState tidx env)
236 | (checktm, _) <- runDelays (const True) $
237 | check rig (initElabInfo InExpr) nest env !(reify defs ttimp')
238 | (Just (glueBack defs env exp'))
239 | empty <- clearDefs defs
240 | nf empty env checktm
241 | elabCon defs "GetDecEqConPairs" [_, x1]
243 | NTCon _ n _ _ <- evalClosure defs x1
244 | | _ => failWith defs "not a type constructor"
245 | Just (TCon arty params _ _ _ cons _) <- lookupDefExact n (gamma defs)
246 | | _ => failWith defs "not a type constructor"
247 | gdefs' <- traverse (\con => lookupCtxtExact con (gamma defs)) (fromMaybe [] cons)
248 | let getNFArgs : NF [] -> Core (List (NF []))
249 | getNFArgs (NBind fc _ (Pi _ _ _ _) sc) = do
250 | res <- sc defs (MkClosure defaultOpts [] [] (Erased fc Placeholder))
252 | getNFArgs (NTCon _ _ _ sp) = traverse (evalClosure defs) (toList (map snd sp))
253 | getNFArgs x = pure []
254 | let mkCon : GlobalDef -> Core (String, List (NF []))
256 | let name : String = nameRoot condef.fullname
257 | nfcon <- nf defs [] condef.type
258 | args <- getNFArgs nfcon
260 | let gdefs : List GlobalDef = catMaybes gdefs'
261 | cons : List (String, List (NF [])) <- traverse mkCon gdefs
262 | let allPairs = [(x, y) | x <- cons, y <- cons, fst x /= fst y]
263 | ++ (map (\t => (t, t)) cons)
264 | let validateNFArg : (NF [], NF []) -> Core Bool
265 | validateNFArg (NPrimVal _ x, NPrimVal _ y) = pure $
x == y
266 | validateNFArg (NDCon _ x _ _ xcls, NDCon _ y _ _ ycls) = case (x == y) of
268 | xargs <- traverse (evalClosure defs) (map Builtin.snd xcls)
269 | yargs <- traverse (evalClosure defs) (map Builtin.snd ycls)
270 | res <- traverse validateNFArg (zip xargs yargs)
271 | pure $
and (map delay res)
272 | False => pure False
273 | validateNFArg (_, _) = pure True
274 | let validatePair : ((String, List (NF [])), (String, List (NF [])))
275 | -> Core (Maybe (String, String))
276 | validatePair ((nx, xargs), (ny, yargs)) =
278 | then pure (Just (nx, ny))
280 | res <- traverse validateNFArg (zip xargs yargs)
281 | if (and (map delay res)) then pure (Just (nx, ny)) else pure Nothing
282 | vals <- Core.Core.traverse validatePair allPairs
283 | scriptRet $
(toList params, catMaybes vals)
284 | elabCon defs "Quote" [exp, tm]
285 | = do tm' <- evalClosure defs tm
287 | empty <- clearDefs defs
288 | scriptRet $
map rawName !(unelabUniqueBinders env !(quote empty env tm'))
289 | elabCon defs "Lambda" [x, _, scope]
290 | = do empty <- clearDefs defs
291 | NBind bfc x (Lam fc' c p ty) sc <- evalClosure defs scope
292 | | _ => failWith defs "Not a lambda"
293 | n <- genVarName "x"
294 | sc' <- sc defs (toClosure withAll env (Ref bfc Bound n))
295 | qsc <- quote empty env sc'
296 | let lamsc = refToLocal n x qsc
298 | qty <- quote empty env ty
299 | let env' = Lam fc' c qp qty :: env
300 | runsc <- elabScript rig fc (weaken nest) env'
301 | !(nf defs env' lamsc) Nothing
302 | nf empty env (Bind bfc x (Lam fc' c qp qty) !(quote empty env' runsc))
304 | quotePi : PiInfo (Closure vars) -> Core (PiInfo (Term vars))
305 | quotePi Explicit = pure Explicit
306 | quotePi Implicit = pure Implicit
307 | quotePi AutoImplicit = pure AutoImplicit
308 | quotePi (DefImplicit t) = failWith defs "Can't add default lambda"
309 | elabCon defs "Goal" []
310 | = do let Just gty = exp
311 | | Nothing => nfOpts withAll defs env
312 | !(reflect fc defs False env (the (Maybe RawImp) Nothing))
314 | scriptRet (Just $
map rawName $
!(unelabUniqueBinders env ty))
315 | elabCon defs "LocalVars" []
317 | elabCon defs "GenSym" [str]
318 | = do str' <- evalClosure defs str
319 | n <- genVarName !(reify defs str')
321 | elabCon defs "InCurrentNS" [n]
322 | = do n' <- evalClosure defs n
323 | nsn <- inCurrentNS !(reify defs n')
325 | elabCon defs "GetType" [n]
326 | = do n' <- evalClosure defs n
327 | res <- lookupTyName !(reify defs n') (gamma defs)
328 | scriptRet !(traverse unelabType res)
330 | unelabType : (Name, Int, ClosedTerm) -> Core (Name, RawImp)
331 | unelabType (n, _, ty)
332 | = do nty <- normaliseHoles defs Env.empty ty
333 | ity <- unelabUniqueBinders Env.empty nty
334 | pure (n, map rawName ity)
335 | elabCon defs "GetInfo" [n]
336 | = do n' <- evalClosure defs n
337 | res <- lookupNameInfo !(reify defs n') (gamma defs)
339 | elabCon defs "GetVis" [n]
340 | = do dn <- reify defs !(evalClosure defs n)
341 | ds <- lookupCtxtName dn (gamma defs)
342 | scriptRet $
map (\(n,_,d) => (n, collapseDefault $
visibility d)) ds
343 | elabCon defs "GetLocalType" [n]
344 | = do n' <- evalClosure defs n
346 | case defined n env of
347 | Just (MkIsDefined rigb lv) =>
348 | do let binder = getBinder lv env
349 | let bty = binderType binder
350 | scriptRet $
map rawName !(unelabUniqueBinders env bty)
351 | _ => failWith defs $
show n ++ " is not a local variable"
352 | elabCon defs "GetCons" [n]
353 | = do n' <- evalClosure defs n
354 | cn <- reify defs n'
355 | Just (TCon _ _ _ _ _ cons _) <-
356 | lookupDefExact cn (gamma defs)
357 | | _ => failWith defs $
show cn ++ " is not a type"
358 | scriptRet $
fromMaybe [] cons
359 | elabCon defs "GetReferredFns" [n]
360 | = do dn <- reify defs !(evalClosure defs n)
361 | Just def <- lookupCtxtExact dn (gamma defs)
362 | | Nothing => failWith defs $
show dn ++ " is not a definition"
363 | ns <- deepRefersTo def
365 | elabCon defs "GetCurrentFn" []
366 | = do defs <- get Ctxt
367 | scriptRet defs.defsStack
368 | elabCon defs "GetFC" []
370 | elabCon defs "Declare" [d]
371 | = do d' <- evalClosure defs d
372 | decls <- reify defs d'
373 | List.traverse_ (processDecl [] (MkNested []) Env.empty) decls
375 | elabCon defs "ReadFile" [lk, pth]
376 | = do pathPrefix <- lookupDir defs !(evalClosure defs lk)
377 | path <- reify defs !(evalClosure defs pth)
378 | validatePath defs path
379 | let fullPath = joinPath [pathPrefix, path]
380 | True <- coreLift $
exists fullPath
381 | | False => scriptRet $
Nothing {ty=String}
382 | contents <- readFile fullPath
383 | scriptRet $
Just contents
384 | elabCon defs "WriteFile" [lk, pth, contents]
385 | = do pathPrefix <- lookupDir defs !(evalClosure defs lk)
386 | path <- reify defs !(evalClosure defs pth)
387 | validatePath defs path
388 | contents <- reify defs !(evalClosure defs contents)
389 | let fullPath = joinPath [pathPrefix, path]
390 | whenJust (parent fullPath) ensureDirectoryExists
391 | writeFile fullPath contents
393 | elabCon defs "IdrisDir" [lk]
394 | = do evalClosure defs lk >>= lookupDir defs >>= scriptRet
395 | elabCon defs n args = failWith defs $
"unexpected Elab constructor " ++ n ++
396 | ", or incorrect count of arguments: " ++ show (length args)
397 | elabScript rig fc nest env script exp
398 | = do defs <- get Ctxt
399 | empty <- clearDefs defs
400 | throw (BadRunElab fc env !(quote empty env script) "script is not a data value")
403 | checkRunElab : {vars : _} ->
404 | {auto c : Ref Ctxt Defs} ->
405 | {auto m : Ref MD Metadata} ->
406 | {auto u : Ref UST UState} ->
407 | {auto e : Ref EST (EState vars)} ->
408 | {auto s : Ref Syn SyntaxInfo} ->
409 | {auto o : Ref ROpts REPLOpts} ->
410 | RigCount -> ElabInfo ->
411 | NestedNames vars -> Env Term vars ->
412 | FC -> (requireExtension : Bool) -> RawImp -> Maybe (Glued vars) ->
413 | Core (Term vars, Glued vars)
414 | checkRunElab rig elabinfo nest env fc reqExt script exp
415 | = do expected <- mkExpected exp
417 | unless (not reqExt || isExtension ElabReflection defs) $
418 | throw (GenericMsg fc "%language ElabReflection not enabled")
419 | let n = NS reflectionNS (UN $
Basic "Elab")
420 | elabtt <- appCon fc defs n [expected]
421 | (stm, sty) <- runDelays (const True) $
422 | check rig elabinfo nest env script (Just (gnf env elabtt))
423 | solveConstraints inTerm Normal
425 | nfstm <- nfOpts withAll defs env stm
426 | ntm <- logTime 2 "Elaboration script" $
427 | elabScript rig fc nest env nfstm $
Just (gnf env expected)
429 | empty <- clearDefs defs
430 | pure (!(quote empty env ntm), gnf env expected)
432 | mkExpected : Maybe (Glued vars) -> Core (Term vars)
433 | mkExpected (Just ty) = pure !(getTerm ty)
435 | = do nm <- genName "scriptTy"
437 | metaVar fc erased env nm (TType fc u)