0 | module TTImp.Elab.RunElab
  1 |
  2 | import Core.Directory
  3 | import Core.Env
  4 | import Core.Metadata
  5 | import Core.Reflect
  6 | import Core.Unify
  7 | import Core.Value
  8 |
  9 | import Data.List
 10 | import Data.Maybe
 11 |
 12 | import Idris.Resugar
 13 | import Idris.REPL.Opts
 14 | import Idris.Pretty
 15 | import Idris.Syntax
 16 |
 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 -- for PageWidth
 22 | import Libraries.Utils.Path
 23 |
 24 | import TTImp.Elab.Check
 25 | import TTImp.Elab.Delayed
 26 | import TTImp.Reflect
 27 | import TTImp.TTImp
 28 | import TTImp.TTImp.Functor
 29 | import TTImp.Unelab
 30 |
 31 | import System.File.Meta
 32 |
 33 | %default covering
 34 |
 35 | record NameInfo where
 36 |   constructor MkNameInfo
 37 |   nametype : NameType
 38 |
 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 } ))
 44 |                    res)
 45 |
 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]
 50 |
 51 | deepRefersTo : {auto c : Ref Ctxt Defs} ->
 52 |                GlobalDef -> Core (List Name)
 53 | deepRefersTo def = do
 54 |   defs <- get Ctxt
 55 |   map nub $ clos empty defs $ refs' defs def
 56 |   -- we don't start with `[defs.fullname]` to distinguish between recursive and non-recursive definitions
 57 |   where
 58 |     refs' : Defs -> GlobalDef -> List Name
 59 |     refs' defs def = keys (refersTo def)
 60 |
 61 |     refs : Defs -> Name -> Core (List Name)
 62 |     refs defs n = maybe [] (refs' defs) <$> lookupCtxtExact n (gamma defs)
 63 |
 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
 68 |       Nothing => do
 69 |         let all' = insert n () all
 70 |         let ns' = !(refs defs n) ++ ns
 71 |         clos all' defs ns'
 72 |
 73 | export
 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) ->
 82 |              Core (NF vars)
 83 | elabScript rig fc nest env script@(NDCon nfc nm t ar args) exp
 84 |     = do defs <- get Ctxt
 85 |          fnm <- toFullNames nm
 86 |          case fnm of
 87 |               NS ns (UN (Basic n))
 88 |                  => if ns == reflectionNS
 89 |                       then elabCon defs n (map snd args)
 90 |                              `catch` \case -- wrap into `RunElabFail` any non-elab error
 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
 96 |   where
 97 |     failWith : Defs -> String -> Core a
 98 |     failWith defs desc
 99 |       = do empty <- clearDefs defs
100 |            throw (BadRunElab fc env !(quote empty env script) desc)
101 |
102 |     scriptRet : Reflect a => a -> Core (NF vars)
103 |     scriptRet tm
104 |         = do defs <- get Ctxt
105 |              nfOpts withAll defs env !(reflect fc defs False env tm)
106 |
107 |     reifyFC : Defs -> Closure vars -> Core FC
108 |     reifyFC defs mbfc = pure $ case !(evalClosure defs mbfc >>= reify defs) of
109 |       EmptyFC => fc
110 |       x       => x
111 |
112 |     -- parses and resolves `Language.Reflection.LookupDir`
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
123 |                             syn <- get Syn
124 |                             let parentIfNeeded = if doParent then parent else pure
125 |                             let moduleSuffix = toList $ (head' syn.saveMod >>= parentIfNeeded) <&> toPath
126 |                             pure $ joinPath $ sd :: moduleSuffix
127 |              case n of
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"
134 |     lookupDir defs lk
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")
138 |
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"
145 |       pure ()
146 |       where
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
153 |
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]
159 |         -- fm : A -> B
160 |         -- elab : A
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]
166 |         -- actF : Elab (A -> B)
167 |         -- actX : Elab A
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]
173 |         -- act : Elab A
174 |         -- k : A -> Elab B
175 |         -- 1) Run elabScript on act stripping off Elab
176 |         -- 2) Evaluate the resulting act
177 |         -- 3) apply k to the result of (2)
178 |         -- 4) Run elabScript on the result stripping off Elab
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')
191 |              scriptRet ()
192 |     elabCon defs "Try" [_, elab1, elab2]
193 |         = tryUnify (do constart <- getNextEntry
194 |                        res <- elabScript rig fc nest env !(evalClosure defs elab1) exp
195 |                        -- We ensure that all of the constraints introduced during the elab script
196 |                        -- have been solved. This guarantees that we do not mistakenly succeed even
197 |                        -- though e.g. a proof search got delayed.
198 |                        solveConstraintsAfter constart inTerm LastChance
199 |                        pure res)
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
206 |                      reify defs str'
207 |              scriptRet ()
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'))
216 |              scriptRet ()
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
225 |              scriptRet ()
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]
242 |         = do
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))
251 |                     getNFArgs res
252 |                 getNFArgs (NTCon _ _ _ sp) = traverse (evalClosure defs) (toList (map snd sp))
253 |                 getNFArgs x = pure []
254 |             let mkCon : GlobalDef -> Core (String, List (NF []))
255 |                 mkCon condef = do
256 |                     let name : String = nameRoot condef.fullname
257 |                     nfcon <- nf defs [] condef.type
258 |                     args <- getNFArgs nfcon
259 |                     pure (name, args)
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
267 |                     True => do
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)) =
277 |                     if (nx == ny)
278 |                     then pure (Just (nx, ny))
279 |                     else do
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
286 |              defs <- get Ctxt
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
297 |              qp <- quotePi p
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 -- (map weaken exp)
302 |              nf empty env (Bind bfc x (Lam fc' c qp qty) !(quote empty env' runsc))
303 |        where
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))
313 |              ty <- getTerm gty
314 |              scriptRet (Just $ map rawName $ !(unelabUniqueBinders env ty))
315 |     elabCon defs "LocalVars" []
316 |         = scriptRet vars
317 |     elabCon defs "GenSym" [str]
318 |         = do str' <- evalClosure defs str
319 |              n <- genVarName !(reify defs str')
320 |              scriptRet n
321 |     elabCon defs "InCurrentNS" [n]
322 |         = do n' <- evalClosure defs n
323 |              nsn <- inCurrentNS !(reify defs n')
324 |              scriptRet nsn
325 |     elabCon defs "GetType" [n]
326 |         = do n' <- evalClosure defs n
327 |              res <- lookupTyName !(reify defs n') (gamma defs)
328 |              scriptRet !(traverse unelabType res)
329 |       where
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)
338 |              scriptRet res
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
345 |              n <- reify 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
364 |              scriptRet ns
365 |     elabCon defs "GetCurrentFn" []
366 |         = do defs <- get Ctxt
367 |              scriptRet defs.defsStack
368 |     elabCon defs "GetFC" []
369 |         = scriptRet fc
370 |     elabCon defs "Declare" [d]
371 |         = do d' <- evalClosure defs d
372 |              decls <- reify defs d'
373 |              List.traverse_ (processDecl [] (MkNested []) Env.empty) decls
374 |              scriptRet ()
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
392 |              scriptRet ()
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")
401 |
402 | export
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
416 |          defs <- get Ctxt
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
424 |          defs <- get Ctxt -- checking might have resolved some holes
425 |          nfstm <- nfOpts withAll defs env stm
426 |          ntm <- logTime 2 "Elaboration script" $
427 |                   elabScript rig fc nest env nfstm $ Just (gnf env expected)
428 |          defs <- get Ctxt -- might have updated as part of the script
429 |          empty <- clearDefs defs
430 |          pure (!(quote empty env ntm), gnf env expected)
431 |   where
432 |     mkExpected : Maybe (Glued vars) -> Core (Term vars)
433 |     mkExpected (Just ty) = pure !(getTerm ty)
434 |     mkExpected Nothing
435 |         = do nm <- genName "scriptTy"
436 |              u <- uniVar fc
437 |              metaVar fc erased env nm (TType fc u)
438 |