08eb78a5b2
This PR sets up the new integrated test/bench suite. It then migrates all benchmarks and some related tests to the new suite. There's also some documentation and some linting. For now, a lot of the old tests are left alone so this PR doesn't become even larger than it already is. Eventually, all tests should be migrated to the new suite though so there isn't a confusing mix of two systems.
111 lines
3.9 KiB
Text
111 lines
3.9 KiB
Text
import Lean.Elab.Command
|
|
import Lean.Elab.DocString.Builtin
|
|
|
|
set_option doc.verso true
|
|
|
|
/-!
|
|
# Tests for Verso Docstring Metadata
|
|
|
|
These tests ensure that the right information is being saved for Verso docstrings by the builtin
|
|
elaborators.
|
|
-/
|
|
|
|
/-!
|
|
## Infrastructure
|
|
|
|
First, some test infrastructure for checking docstring contents.
|
|
-/
|
|
|
|
section
|
|
open Lean Elab Command Term
|
|
|
|
partial def containsMetadataMatchingInline [Monad m] (inline : Doc.Inline ElabInline) (p : Dynamic → m Bool) : m Bool :=
|
|
match inline with
|
|
| .text .. | .image .. | .linebreak .. | .math .. | .code .. => pure false
|
|
| .concat xs | .bold xs | .emph xs | .link xs _ | .footnote _ xs => xs.anyM (containsMetadataMatchingInline · p)
|
|
| .other container content =>
|
|
p container.val <||> content.anyM (containsMetadataMatchingInline · p)
|
|
|
|
|
|
partial def containsMetadataMatchingBlock [Monad m] (block : Doc.Block ElabInline ElabBlock) (p : Dynamic → m Bool) : m Bool :=
|
|
match block with
|
|
| .code .. => pure false
|
|
| .concat xs | .blockquote xs => xs.anyM (containsMetadataMatchingBlock · p)
|
|
| .ol _ items | .ul items =>
|
|
items.anyM fun ⟨bs⟩ => bs.anyM (containsMetadataMatchingBlock · p)
|
|
| .dl items =>
|
|
items.anyM fun ⟨dt, dd⟩ =>
|
|
dt.anyM (containsMetadataMatchingInline · p) <||> dd.anyM (containsMetadataMatchingBlock · p)
|
|
| .para xs => xs.anyM (containsMetadataMatchingInline · p)
|
|
| .other container content =>
|
|
p container.val <||> content.anyM (containsMetadataMatchingBlock · p)
|
|
|
|
partial def containsMetadataMatchingPart [Monad m] (part : Doc.Part ElabInline ElabBlock Empty) (p : Dynamic → m Bool) : m Bool :=
|
|
part.title.anyM (containsMetadataMatchingInline · p) <||>
|
|
part.content.anyM (containsMetadataMatchingBlock · p) <||>
|
|
part.subParts.anyM (containsMetadataMatchingPart · p)
|
|
|
|
def containsMetadataMatching [Monad m] (docs : VersoDocString) (p : Dynamic → m Bool) : m Bool :=
|
|
docs.text.anyM (containsMetadataMatchingBlock · p) <||>
|
|
docs.subsections.anyM (containsMetadataMatchingPart · p)
|
|
|
|
syntax (name := check) "#verso_docs_contain " ident " where " term : command
|
|
|
|
@[command_elab check]
|
|
unsafe def elabChecker : CommandElab := fun
|
|
| `(command|#verso_docs_contain $name:ident where $predicate:term) => withoutModifyingEnv do
|
|
let env ← getEnv
|
|
let n ← runTermElabM fun _ => mkFreshUserName `pred
|
|
elabCommand <| ← `(def $(mkIdent n) : Dynamic → TermElabM Bool := $predicate)
|
|
let pred ← evalConst (Dynamic → TermElabM Bool) n
|
|
let declName ← runTermElabM fun _ => do realizeGlobalConstNoOverloadWithInfo name
|
|
let verso ←
|
|
match (← findInternalDocString? env declName (includeBuiltin := true)) with
|
|
| some (.inl ..) => throwError m!"`{.ofConstName declName}` has a Markdown docstring"
|
|
| some (.inr verso) => pure verso
|
|
| none => throwError m!"`{.ofConstName declName}` has no docstring"
|
|
if ← runTermElabM fun _ => containsMetadataMatching verso pred then
|
|
pure ()
|
|
else
|
|
throwError "No metadata satisfied the predicate"
|
|
| _ => throwUnsupportedSyntax
|
|
|
|
/-!
|
|
## Tests
|
|
|
|
Here, we test the expected metadata for code blocks and inline elements.
|
|
-/
|
|
|
|
/--
|
|
```lean
|
|
def y := x
|
|
```
|
|
-/
|
|
def x := ()
|
|
|
|
#verso_docs_contain x where fun y => do
|
|
if let some v := y.get? Doc.Data.LeanBlock then
|
|
let hasDef := v.commands.code.any fun x =>
|
|
x.1 == "def" && x.2 matches some .keyword
|
|
let hasY := v.commands.code.any fun x =>
|
|
x.1 == "y" && x.2 matches some (.const ..)
|
|
let hasX := v.commands.code.any fun x =>
|
|
x.1 == "x" && x.2 matches some (.const ``x ..)
|
|
pure <| hasDef && hasY && hasX
|
|
else
|
|
pure false
|
|
|
|
/--
|
|
{lean}`foo x`
|
|
-/
|
|
def foo (x : Nat) := Nat.succ x
|
|
|
|
#verso_docs_contain foo where fun y => do
|
|
if let some v := y.get? Doc.Data.LeanTerm then
|
|
let hasFoo := v.term.code.any fun x =>
|
|
x.1 == "foo" && x.2 matches some (.const ``foo ..)
|
|
let hasX := v.term.code.any fun x =>
|
|
x.1 == "x" && x.2 matches some (.var `x ..)
|
|
pure <| hasFoo && hasX
|
|
else
|
|
pure false
|