blob: b589f3f4c37f5800359e99aba3fcb635cbe010e8 [file]
/-
Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Leonardo de Moura
-/
module
prelude
public import Lean.Meta.Sorry
public import Lean.Util.CollectAxioms
public import Lean.OriginalConstKind
import all Lean.OriginalConstKind -- for accessing `privateConstKindsExt`
public section
namespace Lean
/-- Adds given declaration to the environment, respecting `debug.skipKernelTC`. -/
def Kernel.Environment.addDecl (env : Environment) (opts : Options) (decl : Declaration)
(cancelTk? : Option IO.CancelToken := none) : Except Exception Environment :=
if debug.skipKernelTC.get opts then
addDeclWithoutChecking env decl
else
addDeclCore env (Core.getMaxHeartbeats opts).toUSize decl cancelTk?
private def Environment.addDeclAux (env : Environment) (opts : Options) (decl : Declaration)
(cancelTk? : Option IO.CancelToken := none) : Except Kernel.Exception Environment :=
env.addDeclCore (Core.getMaxHeartbeats opts).toUSize decl cancelTk? (!debug.skipKernelTC.get opts)
private def isNamespaceName : Name → Bool
| .str .anonymous _ => true
| .str p _ => isNamespaceName p
| _ => false
private def registerNamePrefixes (env : Environment) (name : Name) : Environment :=
match name with
| .str _ s =>
if s.front == '_' then
-- Do not register namespaces that only contain internal declarations.
env
else
go env name
| _ => env
where go env
| .str p _ => if isNamespaceName p then go (env.registerNamespace p) p else env
| _ => env
/-- If `warn.sorry` is set to true, then, so long as the message log does not already have any errors,
declarations with `sorryAx` generate the "declaration uses `sorry`" warning. -/
register_builtin_option warn.sorry : Bool := {
defValue := true
descr := "warn about uses of `sorry` in declarations added to the environment"
}
/--
If the `warn.sorry` option is set to true and there are no errors in the log already,
logs a warning if the declaration uses `sorry`.
-/
def warnIfUsesSorry (decl : Declaration) : CoreM Unit := do
if warn.sorry.get (← getOptions) then
if !(← MonadLog.hasErrors) && decl.hasSorry then
-- Find an actual sorry expression to use for `sorry`.
-- That way the user can hover over it to see its type and use "go to definition" if it is a labeled sorry.
let findSorry : StateRefT (Array (Bool × MessageData)) MetaM Unit := decl.forEachSorryM fun s => do
let s' ← addMessageContext s
modify fun arr => arr.push (s.isSyntheticSorry, s')
let (_, sorries) ← findSorry |>.run #[] |>.run'
-- Prefer reporting a synthetic sorry.
-- These can appear without logged errors if `decl` is referring to declarations with elaboration errors;
-- that's where a user should direct their focus.
if let some (_, s) := sorries.find? (·.1) <|> sorries[0]? then
logWarning <| .tagged `hasSorry m!"declaration uses `{s}`"
else
-- This case should not happen, but it ensures a warning will get logged no matter what.
logWarning <| .tagged `hasSorry m!"declaration uses `sorry`"
builtin_initialize
registerTraceClass `addDecl
/--
Adds the given declaration to the environment's private scope, deriving a suitable presentation in
the public scope if under the module system and if the declaration is not private. If `forceExpose`
is true, exposes the declaration body, i.e. preserves the full representation in the public scope,
independently of `Environment.isExporting` and even for theorems.
-/
def addDecl (decl : Declaration) (forceExpose := false) : CoreM Unit :=
withTraceNode `addDecl (fun _ => return m!"adding declarations {decl.getNames}") do
-- register namespaces for newly added constants; this used to be done by the kernel itself
-- but that is incompatible with moving it to a separate task
-- NOTE: we do not use `getTopLevelNames` here so that inductive types are registered as
-- namespaces
modifyEnv (decl.getNames.foldl registerNamePrefixes)
-- convert `Declaration` to `ConstantInfo` to use as a preliminary value in the environment until
-- kernel checking has finished; not all cases are supported yet
let mut exportedInfo? := none
let (name, info, kind) ← match decl with
| .thmDecl thm =>
if !forceExpose && (← getEnv).header.isModule then
trace[addDecl] "exporting theorem {thm.name} as axiom"
exportedInfo? := some <| .axiomInfo { thm with isUnsafe := false }
pure (thm.name, .thmInfo thm, .thm)
| .defnDecl defn | .mutualDefnDecl [defn] =>
if !forceExpose && (← getEnv).header.isModule && !(← getEnv).isExporting then
trace[addDecl] "exporting definition {defn.name} as axiom"
exportedInfo? := some <| .axiomInfo { defn with isUnsafe := defn.safety == .unsafe }
pure (defn.name, .defnInfo defn, .defn)
| .opaqueDecl op =>
if !forceExpose && (← getEnv).header.isModule && !(← getEnv).isExporting then
trace[addDecl] "exporting opaque {op.name} as axiom"
exportedInfo? := some <| .axiomInfo { op with }
pure (op.name, .opaqueInfo op, .opaque)
| .axiomDecl ax => pure (ax.name, .axiomInfo ax, .axiom)
| _ =>
trace[addDecl] "no matching async adding rules, adding synchronously"
return (← doAdd)
-- Check early so we can avoid related env ext panics that would happen before the check in the
-- kernel.
if (← getEnv).containsOnBranch name then
throwKernelException <| .alreadyDeclared (← getEnv).toKernelEnv name
if decl.getTopLevelNames.all isPrivateName then
if (← ResolveName.backward.privateInPublic.getM) then
trace[addDecl] "private decl under `privateInPublic`, exporting as is"
exportedInfo? := some info
else
trace[addDecl] "not exporting private declaration at all"
exportedInfo? := none
else
-- preserve original constant kind in extension if different from exported one
if exportedInfo?.isSome then
modifyEnv (privateConstKindsExt.insert · name kind)
else
trace[addDecl] "no matching exporting rules, exporting as is"
exportedInfo? := some info
let env ← getEnv
-- no environment extension changes to report after kernel checking; ensures we do not
-- accidentally wait for this snapshot when querying extension states
let async ← env.addConstAsync (reportExts := false) name kind
(exportedKind? := exportedInfo?.map (.ofConstantInfo))
-- report preliminary constant info immediately
async.commitConst async.asyncEnv (some info) (exportedInfo? <|> info)
setEnv async.mainEnv
let doAddAndCommit := do
setEnv async.asyncEnv
try
doAdd
finally
async.commitCheckEnv (← getEnv)
if Elab.async.get (← getOptions) then
let cancelTk ← IO.CancelToken.new
let checkAct ← Core.wrapAsyncAsSnapshot (cancelTk? := cancelTk) fun _ => doAddAndCommit
let t ← BaseIO.mapTask checkAct env.checked
-- Do not display reporting range; most uses of `addDecl` are for registering auxiliary decls
-- users should not worry about and other callers can add a separate task with ranges
-- themselves, see `MutualDef`.
Core.logSnapshotTask { stx? := none, reportingRange := .skip, task := t, cancelTk? := cancelTk }
else
try
doAddAndCommit
finally
setEnv async.mainEnv
where
doAdd := do
profileitM Exception "type checking" (← getOptions) do
withTraceNode `Kernel (return m!"{exceptEmoji ·} typechecking declarations {decl.getTopLevelNames}") do
warnIfUsesSorry decl
try
let env ← (← getEnv).addDeclAux (← getOptions) decl (← read).cancelTk?
|> ofExceptKernelException
setEnv env
catch ex =>
-- avoid follow-up errors by (trying to) add broken decl as axiom
addAsAxiom
throw ex
addAsAxiom := do
-- try to add as axiom with given type for def/theorem
match decl with
| .defnDecl d | .thmDecl d =>
let fallbackDecl := .axiomDecl {
name := d.name, levelParams := d.levelParams, type := d.type, isUnsafe := false
}
try
let env ← (← getEnv).addDeclAux (← getOptions) fallbackDecl (← read).cancelTk?
|> ofExceptKernelException
setEnv env
return
catch _ => pure ()
| _ => pure ()
-- otherwise, add as axiom with type `sorry`
for n in decl.getNames do
let fallbackDecl := .axiomDecl {
name := n, levelParams := []
type := mkApp2 (mkConst ``sorryAx [1]) (mkSort 0) (mkConst ``true), isUnsafe := false
}
try
let env ← (← getEnv).addDeclAux (← getOptions) fallbackDecl (← read).cancelTk?
|> ofExceptKernelException
setEnv env
return
catch _ => pure ()
def addAndCompile (decl : Declaration) (logCompileErrors : Bool := true) : CoreM Unit := do
addDecl decl
compileDecl decl (logErrors := logCompileErrors)
end Lean