Reserved names.

We use reserved names for automatically generated theorems (e.g., equational theorems). Automation may register new reserved name predicates. In this module, we just check the registered predicates, but do not trigger actions associated with them. For example, give a definition foo, we flag foo.def as reserved symbol.

def Lean.throwReservedNameNotAvailable {m : Type → Type} [Monad m] [Lean.MonadError m] (declName : Lake.Name) (reservedName : Lake.Name) : m Unit

Equations

• One or more equations did not get rendered due to their size.

def Lean.ensureReservedNameAvailable {m : Type → Type} [Monad m] [Lean.MonadEnv m] [Lean.MonadError m] (declName : Lake.Name) (suffix : String) : m Unit

Equations

• One or more equations did not get rendered due to their size.

opaque Lean.reservedNamePredicatesRef : IO.Ref (Array (Lean.Environment → Lake.Name → Bool))

Global reference containing all reserved name predicates.

def Lean.registerReservedNamePredicate (p : Lean.Environment → Lake.Name → Bool) : IO Unit

Registers a new reserved name predicate.

Equations

• One or more equations did not get rendered due to their size.

opaque Lean.reservedNamePredicatesExt : Lean.EnvExtension (Array (Lean.Environment → Lake.Name → Bool))

def Lean.isReservedName (env : Lean.Environment) (name : Lake.Name) : Bool

Returns true if name is a reserved name.

Equations

• Lean.isReservedName env name = (Lean.reservedNamePredicatesExt.getState env).any fun (x : Lean.Environment → Lake.Name → Bool) => x env name

We use aliases to implement the export <id> (<id>+) command. An export A (x) in the namespace B produces an alias B.x ~> A.x.

@[reducible, inline]

abbrev Lean.AliasState : Type

Equations

• Lean.AliasState = Lean.SMap Lake.Name (List Lake.Name)

@[reducible, inline]

abbrev Lean.AliasEntry : Type

Equations

• Lean.AliasEntry = (Lake.Name × Lake.Name)

def Lean.addAliasEntry (s : Lean.AliasState) (e : Lean.AliasEntry) : Lean.AliasState

Equations

• One or more equations did not get rendered due to their size.

opaque Lean.aliasExtension : Lean.SimplePersistentEnvExtension Lean.AliasEntry Lean.AliasState

@[export lean_add_alias]

def Lean.addAlias (env : Lean.Environment) (a : Lake.Name) (e : Lake.Name) : Lean.Environment

Add alias a for e

Equations

• Lean.addAlias env a e = Lean.PersistentEnvExtension.addEntry Lean.aliasExtension env (a, e)

def Lean.getAliasState (env : Lean.Environment) : Lean.AliasState

Equations

• Lean.getAliasState env = Lean.aliasExtension.getState env

def Lean.getAliases (env : Lean.Environment) (a : Lake.Name) (skipProtected : Bool) : List Lake.Name

Retrieve aliases for a. If skipProtected is true, then the resulting list only includes declarations that are not marked as proctected.

Equations

• One or more equations did not get rendered due to their size.

def Lean.getRevAliases (env : Lean.Environment) (e : Lake.Name) : List Lake.Name

Equations

• One or more equations did not get rendered due to their size.

Global name resolution

def Lean.ResolveName.resolveGlobalName (env : Lean.Environment) (ns : Lake.Name) (openDecls : List Lean.OpenDecl) (id : Lake.Name) : List (Lake.Name × List String)

Primitive global name resolution procedure. It does not trigger actions associated with reserved names. Recall that Lean has reserved names. For example, a definition foo has a reserved name foo.def for theorem containing stating that foo is equal to its definition. The action associated with foo.def automatically proves the theorem. At the macro level, the name is resolved, but the action is not executed.

Equations

• Lean.ResolveName.resolveGlobalName env ns openDecls id = Lean.ResolveName.resolveGlobalName.loop env ns openDecls (Lean.extractMacroScopes id) (Lean.extractMacroScopes id).name []

def Lean.ResolveName.resolveGlobalName.loop (env : Lean.Environment) (ns : Lake.Name) (openDecls : List Lean.OpenDecl) (extractionResult : Lean.MacroScopesView) (id : Lake.Name) (projs : List String) : List (Lake.Name × List String)

Equations

• One or more equations did not get rendered due to their size.
• Lean.ResolveName.resolveGlobalName.loop env ns openDecls extractionResult id projs = []

Namespace resolution

def Lean.ResolveName.resolveNamespaceUsingScope? (env : Lean.Environment) (n : Lake.Name) (ns : Lake.Name) : Option Lake.Name

Equations

• One or more equations did not get rendered due to their size.
• Lean.ResolveName.resolveNamespaceUsingScope? env n (p.str str) = if env.isNamespace (p.str str ++ n) = true then some (p.str str ++ n) else Lean.ResolveName.resolveNamespaceUsingScope? env n p
• Lean.ResolveName.resolveNamespaceUsingScope? env n ns = panicWithPosWithDecl "Lean.ResolveName" "Lean.ResolveName.resolveNamespaceUsingScope?" 200 9 "unreachable code has been reached"

def Lean.ResolveName.resolveNamespaceUsingOpenDecls (env : Lean.Environment) (n : Lake.Name) : List Lean.OpenDecl → List Lake.Name

Equations

• One or more equations did not get rendered due to their size.
• Lean.ResolveName.resolveNamespaceUsingOpenDecls env n [] = []
• Lean.ResolveName.resolveNamespaceUsingOpenDecls env n (head :: ds) = Lean.ResolveName.resolveNamespaceUsingOpenDecls env n ds

def Lean.ResolveName.resolveNamespace (env : Lean.Environment) (ns : Lake.Name) (openDecls : List Lean.OpenDecl) (id : Lake.Name) : List Lake.Name

Given a name id try to find namespaces it may refer to. The resolution procedure works as follows

1- If id is in the scope of namespace commands the namespace s_1. ... . s_n, then we include s_1 . ... . s_i ++ n in the result if it is the name of an existing namespace. We search "backwards", and include at most one of the in the list of resulting namespaces.

2- If id is the exact name of an existing namespace, then include id

3- Finally, for each command open N, include in the result N ++ n if it is the name of an existing namespace. We only consider simple open commands.

Equations

• One or more equations did not get rendered due to their size.

class Lean.MonadResolveName (m : Type → Type) : Type

• getCurrNamespace : m Lake.Name
• getOpenDecls : m (List Lean.OpenDecl)

instance Lean.instMonadResolveNameOfMonadLift (m : Type → Type) (n : Type → Type) [MonadLift m n] [Lean.MonadResolveName m] : Lean.MonadResolveName n

Equations

• Lean.instMonadResolveNameOfMonadLift m n = { getCurrNamespace := liftM Lean.getCurrNamespace, getOpenDecls := liftM Lean.getOpenDecls }

def Lean.resolveGlobalName {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] (id : Lake.Name) : m (List (Lake.Name × List String))

Given a name n, return a list of possible interpretations. Each interpretation is a pair (declName, fieldList), where declName is the name of a declaration in the current environment, and fieldList are (potential) field names. The pair is needed because in Lean . may be part of a qualified name or a field (aka dot-notation). As an example, consider the following definitions

def Boo.x   := 1
def Foo.x   := 2
def Foo.x.y := 3

After open Foo, we have

• resolveGlobalName x => [(Foo.x, [])]
• resolveGlobalName x.y => [(Foo.x.y, [])]
• resolveGlobalName x.z.w => [(Foo.x, [z, w])]

After open Foo open Boo, we have

• resolveGlobalName x => [(Foo.x, []), (Boo.x, [])]
• resolveGlobalName x.y => [(Foo.x.y, [])]
• resolveGlobalName x.z.w => [(Foo.x, [z, w]), (Boo.x, [z, w])]

Equations

• One or more equations did not get rendered due to their size.

def Lean.resolveNamespaceCore {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadError m] (id : Lake.Name) (allowEmpty : optParam Bool false) : m (List Lake.Name)

Given a namespace name, return a list of possible interpretations. Names extracted from syntax should be passed to resolveNamespace instead.

Equations

• One or more equations did not get rendered due to their size.

def Lean.resolveNamespace {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadError m] : Lean.Ident → m (List Lake.Name)

Given a namespace identifier, return a list of possible interpretations.

Equations

• One or more equations did not get rendered due to their size.
• Lean.resolveNamespace x = Lean.throwErrorAt x.raw ((Lean.MessageData.ofFormat ∘ Lean.format) (toString "expected identifier"))

def Lean.resolveUniqueNamespace {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadError m] (id : Lean.Ident) : m Lake.Name

Given a namespace identifier, return the unique interpretation or else fail.

Equations

• One or more equations did not get rendered due to their size.

def Lean.filterFieldList {m : Type → Type} [Monad m] [Lean.MonadError m] (n : Lake.Name) (cs : List (Lake.Name × List String)) : m (List Lake.Name)

Helper function for resolveGlobalConstCore.

Equations

• One or more equations did not get rendered due to their size.

def Lean.ensureNoOverload {m : Type → Type} [Monad m] [Lean.MonadError m] (n : Lake.Name) (cs : List Lake.Name) : m Lake.Name

Helper function for resolveGlobalConstNoOverloadCore

Equations

• One or more equations did not get rendered due to their size.
• Lean.ensureNoOverload n [ns] = pure ns

def Lean.resolveGlobalConstNoOverloadCore {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadError m] (n : Lake.Name) : m Lake.Name

For identifiers taken from syntax, use resolveGlobalConstNoOverload instead, which respects preresolved names.

Equations

• Lean.resolveGlobalConstNoOverloadCore n = do let __do_lift ← Lean.resolveGlobalConstCore n Lean.ensureNoOverload n __do_lift

def Lean.preprocessSyntaxAndResolve {m : Type → Type} [Monad m] [Lean.MonadError m] (stx : Lean.Syntax) (k : Lake.Name → m (List Lake.Name)) : m (List Lake.Name)

Equations

• One or more equations did not get rendered due to their size.
• Lean.preprocessSyntaxAndResolve stx k = Lean.throwErrorAt stx ((Lean.MessageData.ofFormat ∘ Lean.format) (toString "expected identifier"))

def Lean.resolveGlobalConst {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadError m] (stx : Lean.Syntax) : m (List Lake.Name)

Interprets the syntax n as an identifier for a global constant, and returns a list of resolved constant names that it could be referring to based on the currently open namespaces. This should be used instead of resolveGlobalConstCore for identifiers taken from syntax because Syntax objects may have names that have already been resolved.

Consider using realizeGlobalConst if you need to handle reserved names, and realizeGlobalConstWithInfo if you want the syntax to show the resulting name's info on hover.

Example:

def Boo.x   := 1
def Foo.x   := 2
def Foo.x.y := 3

After open Foo, we have

• resolveGlobalConst x => [Foo.x]
• resolveGlobalConst x.y => [Foo.x.y]
• resolveGlobalConst x.z.w => error: unknown constant

After open Foo open Boo, we have

• resolveGlobalConst x => [Foo.x, Boo.x]
• resolveGlobalConst x.y => [Foo.x.y]
• resolveGlobalConst x.z.w => error: unknown constant

Equations

• Lean.resolveGlobalConst stx = Lean.preprocessSyntaxAndResolve stx Lean.resolveGlobalConstCore

def Lean.ensureNonAmbiguous {m : Type → Type} [Monad m] [Lean.MonadError m] (id : Lean.Syntax) (cs : List Lake.Name) : m Lake.Name

Given a list of names produced by resolveGlobalConst, throws an error if the list does not contain exactly one element. Recall that resolveGlobalConst does not return empty lists.

Equations

• One or more equations did not get rendered due to their size.
• Lean.ensureNonAmbiguous id [] = panicWithPosWithDecl "Lean.ResolveName" "Lean.ensureNonAmbiguous" 364 11 "unreachable code has been reached"
• Lean.ensureNonAmbiguous id [c] = pure c

def Lean.resolveGlobalConstNoOverload {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadError m] (id : Lean.Syntax) : m Lake.Name

Interprets the syntax n as an identifier for a global constant, and return a resolved constant name. If there are multiple possible interpretations it will throw.

Consider using realizeGlobalConstNoOverload if you need to handle reserved names, and realizeGlobalConstNoOverloadWithInfo if you want the syntax to show the resulting name's info on hover.

Example:

def Boo.x   := 1
def Foo.x   := 2
def Foo.x.y := 3

After open Foo, we have

• resolveGlobalConstNoOverload x => Foo.x
• resolveGlobalConstNoOverload x.y => Foo.x.y
• resolveGlobalConstNoOverload x.z.w => error: unknown constant

After open Foo open Boo, we have

• resolveGlobalConstNoOverload x => error: ambiguous identifier
• resolveGlobalConstNoOverload x.y => Foo.x.y
• resolveGlobalConstNoOverload x.z.w => error: unknown constant

Equations

• Lean.resolveGlobalConstNoOverload id = do let __do_lift ← Lean.resolveGlobalConst id Lean.ensureNonAmbiguous id __do_lift

def Lean.unresolveNameGlobal {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] (n₀ : Lake.Name) (fullNames : optParam Bool false) : m Lake.Name

Finds a name that unambiguously resolves to the given name n₀. Considers suffixes of n₀ and suffixes of aliases of n₀ when "unresolving". Aliases are considered first.

When fullNames is true, returns either n₀ or _root_.n₀.

This function is meant to be used for pretty printing. If n₀ is an accessible name, then the result will be an accessible name.

Equations

• One or more equations did not get rendered due to their size.

def Lean.unresolveNameGlobal.unresolveNameCore {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] (n₀ : Lake.Name) (n : Lake.Name) : m (Option Lake.Name)

Equations

• One or more equations did not get rendered due to their size.

def Lean.unresolveNameGlobalAvoidingLocals {m : Type → Type} [Monad m] [Lean.MonadResolveName m] [Lean.MonadEnv m] [Lean.MonadLCtx m] (n₀ : Lake.Name) (fullNames : optParam Bool false) : m Lake.Name

Equations

• One or more equations did not get rendered due to their size.