pub const REFUSED_WORDS: [&str; 37] = [
"run_cmd",
"run_elab",
"run_meta",
"run_tac",
"initialize",
"builtin_initialize",
"macro",
"macro_rules",
"elab",
"elab_rules",
"syntax",
"notation",
"infix",
"infixl",
"infixr",
"prefix",
"postfix",
"binder_predicate",
"declare_syntax_cat",
"unif_hint",
"export",
"scoped",
"unsafe",
"implemented_by",
"extern",
"attribute",
"simproc",
"dsimproc",
"simproc_decl",
"dsimproc_decl",
"builtin_simproc",
"builtin_dsimproc",
"register_simp_attr",
"register_option",
"register_builtin_option",
"deriving",
"AverCertChecker",
];
pub const ADMITTED_HASH_COMMANDS: [&str; 3] = ["#guard_msgs", "#print", "#check"];
pub const ADMITTED_OPTIONS: [&str; 7] = [
"autoImplicit",
"relaxedAutoImplicit",
"maxHeartbeats",
"maxRecDepth",
"smartUnfolding",
"synthInstance.maxSize",
"synthInstance.maxHeartbeats",
];
pub const REFUSED_OPEN_ROOTS: [&str; 2] = ["Lean", "Lake"];
pub fn option_admitted(name: &str) -> bool {
ADMITTED_OPTIONS.contains(&name)
|| name
.strip_prefix("linter.")
.is_some_and(|rest| !rest.is_empty())
}
pub fn code_exec_token(text: &str) -> Option<&'static str> {
let chars: Vec<char> = text.chars().collect();
let tokens = tokenize(&chars);
first_refused(&chars, &tokens)
}
pub const DERIVING_CLASSES: [&str; 3] = ["BEq", "DecidableEq", "Inhabited"];
pub const DERIVING_INSTANCE_CLASSES: [&str; 2] = ["ReflBEq", "LawfulBEq"];
pub fn admitted_deriving_end(chars: &[char], start: usize) -> Option<usize> {
const KEYWORD: &str = "deriving";
let mut at = start + KEYWORD.chars().count();
let spaces = |at: &mut usize| {
let from = *at;
while chars.get(*at) == Some(&' ') {
*at += 1;
}
*at > from
};
let word = |at: &mut usize| -> Option<String> {
let from = *at;
match chars.get(*at) {
Some(first) if first.is_ascii_alphabetic() || *first == '_' => {}
_ => return None,
}
while matches!(chars.get(*at), Some(c) if c.is_ascii_alphanumeric() || *c == '_' || *c == '.' || *c == '\'')
{
*at += 1;
}
Some(chars[from..*at].iter().collect())
};
let list = |at: &mut usize, accept: &dyn Fn(&str) -> bool| -> Option<()> {
loop {
let item = word(at)?;
if !accept(&item) {
return None;
}
let resume = *at;
spaces(at);
if chars.get(*at) == Some(&',') {
*at += 1;
spaces(at);
continue;
}
*at = resume;
return Some(());
}
};
if !spaces(&mut at) {
return None;
}
let resume = at;
if word(&mut at).as_deref() == Some("instance") && spaces(&mut at) {
list(&mut at, &|class| DERIVING_INSTANCE_CLASSES.contains(&class))?;
if !spaces(&mut at) || word(&mut at).as_deref() != Some("for") || !spaces(&mut at) {
return None;
}
list(&mut at, &|name| {
crate::bridge_statement::is_plain_dotted_name(name)
})?;
} else {
at = resume;
list(&mut at, &|class| DERIVING_CLASSES.contains(&class))?;
}
spaces(&mut at);
let line_end = at;
match chars.get(at) {
None => return Some(line_end),
Some('\n') => {}
_ => return None,
}
let mut next = at;
loop {
match chars.get(next) {
Some(c) if c.is_whitespace() => next += 1,
Some('-') if chars.get(next + 1) == Some(&'-') => {
while matches!(chars.get(next), Some(c) if *c != '\n') {
next += 1;
}
}
Some('/') if chars.get(next + 1) == Some(&'-') => {
next = block_comment_end(chars, next)?;
}
_ => break,
}
}
if chars.get(next) == Some(&',') {
return None;
}
let mut probe = next;
if word(&mut probe).as_deref() == Some("with") {
return None;
}
Some(line_end)
}
pub fn lean_module_root(name: &str) -> Result<String, String> {
let stem = name
.strip_suffix(".lean")
.ok_or_else(|| format!("cert file {name:?} is not a Lean file"))?;
let segments: Vec<&str> = stem.split('/').collect();
let valid = segments.iter().all(|segment| {
let mut chars = segment.chars();
matches!(chars.next(), Some(first) if first.is_ascii_alphabetic())
&& chars.all(|character| character.is_ascii_alphanumeric() || character == '_')
});
if valid {
Ok(segments.join("."))
} else {
Err(format!(
"cert file name {name:?} must match ^[A-Za-z][A-Za-z0-9_]*\\.lean$ in every path segment"
))
}
}
fn is_plain_unprimed_name(value: &str) -> bool {
!value.contains('\'') && crate::bridge_statement::is_plain_dotted_name(value)
}
pub fn law_claim_identifiers(
label: &str,
theorem: &str,
corollary: &str,
) -> Result<(), &'static str> {
if !is_plain_unprimed_name(label) {
return Err("label");
}
if !crate::bridge_statement::is_plain_dotted_name(theorem) {
return Err("theorem");
}
if !is_plain_unprimed_name(corollary) {
return Err("corollary");
}
Ok(())
}
fn string_literal_end(chars: &[char], open: usize) -> Option<usize> {
let mut j = open + 1;
while j < chars.len() {
match chars[j] {
'\\' => j += 2, '"' => return Some(j + 1),
_ => j += 1,
}
}
None
}
fn block_comment_end(chars: &[char], open: usize) -> Option<usize> {
let mut depth = 1usize;
let mut j = open + 2;
while j < chars.len() {
if chars[j] == '/' && j + 1 < chars.len() && chars[j + 1] == '-' {
depth += 1;
j += 2;
} else if chars[j] == '-' && j + 1 < chars.len() && chars[j + 1] == '/' {
depth -= 1;
j += 2;
if depth == 0 {
return Some(j);
}
} else {
j += 1;
}
}
None
}
fn char_literal_end(chars: &[char], open: usize) -> Option<usize> {
if chars.get(open + 1) == Some(&'\\') {
if chars.get(open + 2).is_some() && chars.get(open + 3) == Some(&'\'') {
return Some(open + 4);
}
return None;
}
match chars.get(open + 1) {
Some('\'') | None => None, Some(_) => {
if chars.get(open + 2) == Some(&'\'') {
Some(open + 3)
} else {
None
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Token {
Ident(String, usize),
Hash(String, usize),
Symbol(String, usize),
}
impl Token {
fn start(&self) -> usize {
match self {
Token::Ident(_, at) | Token::Hash(_, at) | Token::Symbol(_, at) => *at,
}
}
}
fn is_ident_start(c: char) -> bool {
c.is_ascii_alphabetic() || c == '_' || (!c.is_ascii() && c.is_alphabetic())
}
fn is_ident_continue(c: char) -> bool {
is_ident_start(c)
|| c.is_ascii_digit()
|| c == '\''
|| c == '!'
|| c == '?'
|| (!c.is_ascii() && c.is_alphanumeric())
}
fn interpolated_string_end(chars: &[char], open: usize) -> Option<(usize, Vec<(usize, usize)>)> {
let mut terms = Vec::new();
let mut j = open + 1;
loop {
match *chars.get(j)? {
'\\' => j += 2,
'"' => return Some((j + 1, terms)),
'{' => {
let end = interpolation_term_end(chars, j + 1)?;
terms.push((j + 1, end));
j = end + 1;
}
_ => j += 1,
}
}
}
fn interpolation_term_end(chars: &[char], start: usize) -> Option<usize> {
let mut depth = 0usize;
let mut j = start;
loop {
let c = *chars.get(j)?;
let previous = j.checked_sub(1).map(|p| chars[p]);
match c {
'{' => depth += 1,
'}' if depth == 0 => return Some(j),
'}' => depth -= 1,
'"' if is_interpolation_prefix(chars, j) => {
j = interpolated_string_end(chars, j)?.0;
continue;
}
'"' if matches!(previous, Some('r' | '#' | '!')) => return None,
'"' => {
j = string_literal_end(chars, j)?;
continue;
}
'\'' if !previous.is_some_and(is_ident_continue) => {
if let Some(end) = char_literal_end(chars, j) {
j = end;
continue;
}
}
'-' if chars.get(j + 1) == Some(&'-') => return None,
'/' if chars.get(j + 1) == Some(&'-') => return None,
_ => {}
}
j += 1;
}
}
fn is_interpolation_prefix(chars: &[char], at: usize) -> bool {
at >= 2
&& chars[at - 1] == '!'
&& chars[at - 2] == 's'
&& !(at >= 3 && is_ident_continue(chars[at - 3]))
}
fn tokenize(chars: &[char]) -> Vec<Token> {
let mut tokens = Vec::new();
tokenize_range(chars, 0, chars.len(), &mut tokens);
tokens
}
fn tokenize_range(chars: &[char], start: usize, n: usize, tokens: &mut Vec<Token>) {
let mut pure_code = false;
let mut i = start;
while i < n {
let c = chars[i];
if c.is_whitespace() {
i += 1;
continue;
}
if !pure_code {
if c == '"' {
if is_interpolation_prefix(chars, i) {
match interpolated_string_end(chars, i) {
Some((end, terms)) if end <= n => {
for (term_start, term_end) in terms {
tokenize_range(chars, term_start, term_end, tokens);
}
i = end;
continue;
}
_ => pure_code = true,
}
} else if i > 0 && matches!(chars[i - 1], 'r' | '#' | '!') {
pure_code = true;
} else if let Some(end) = string_literal_end(chars, i) {
i = end;
continue;
} else {
pure_code = true;
}
} else if c == '-' && chars.get(i + 1) == Some(&'-') {
while i < n && chars[i] != '\n' {
i += 1;
}
continue;
} else if c == '/' && chars.get(i + 1) == Some(&'-') {
match block_comment_end(chars, i) {
Some(end) => {
i = end;
continue;
}
None => pure_code = true,
}
} else if c == '\''
&& !matches!(i.checked_sub(1).map(|p| chars[p]), Some(p) if is_ident_continue(p))
&& let Some(end) = char_literal_end(chars, i)
{
i = end;
continue;
}
}
if is_ident_start(c) {
let start = i;
loop {
while i < n && is_ident_continue(chars[i]) {
i += 1;
}
if i + 1 < n && chars[i] == '.' && is_ident_start(chars[i + 1]) {
i += 1;
continue;
}
break;
}
tokens.push(Token::Ident(chars[start..i].iter().collect(), start));
continue;
}
if c.is_ascii_digit() {
while i < n && (chars[i].is_ascii_alphanumeric() || chars[i] == '_') {
i += 1;
}
continue;
}
if c == '#' && chars.get(i + 1).is_some_and(|next| is_ident_start(*next)) {
let start = i;
i += 1;
while i < n && is_ident_continue(chars[i]) {
i += 1;
}
tokens.push(Token::Hash(chars[start..i].iter().collect(), start));
continue;
}
if c == '@' && chars.get(i + 1) == Some(&'[') {
tokens.push(Token::Symbol("@[".to_string(), i));
i += 2;
continue;
}
tokens.push(Token::Symbol(c.to_string(), i));
i += 1;
}
}
const COMMAND_WORDS: [&str; 26] = [
"def",
"theorem",
"lemma",
"abbrev",
"instance",
"structure",
"inductive",
"class",
"namespace",
"section",
"end",
"open",
"set_option",
"variable",
"universe",
"noncomputable",
"private",
"protected",
"partial",
"mutual",
"example",
"opaque",
"axiom",
"import",
"in",
"where",
];
fn first_refused(chars: &[char], tokens: &[Token]) -> Option<&'static str> {
let mut at = 0;
while at < tokens.len() {
match &tokens[at] {
Token::Symbol(symbol, _) => {
if symbol == "@[" {
return Some("@[");
}
if symbol == "«" || symbol == "»" {
return Some("«");
}
}
Token::Hash(command, _) => {
if command == "#eval" {
return Some("#eval");
}
if !ADMITTED_HASH_COMMANDS.contains(&command.as_str()) {
return Some("#command");
}
}
Token::Ident(name, start) => {
if name == "deriving" {
let Some(end) = admitted_deriving_end(chars, *start) else {
return Some("deriving");
};
at += 1;
while tokens.get(at).is_some_and(|token| token.start() < end) {
at += 1;
}
continue;
}
if let Some(word) = name
.split('.')
.find_map(|segment| REFUSED_WORDS.iter().find(|word| **word == segment))
{
return Some(word);
}
if name == "set_option" {
match tokens.get(at + 1) {
Some(Token::Ident(option, _)) if option_admitted(option) => {}
_ => return Some("set_option"),
}
}
if name == "namespace"
&& let Some(Token::Ident(entered, _)) = tokens.get(at + 1)
{
let entered = entered.strip_prefix("_root_.").unwrap_or(entered.as_str());
let root = entered.split('.').next().unwrap_or_default();
if REFUSED_OPEN_ROOTS.contains(&root) {
return Some("namespace Lean");
}
}
if name == "open" {
let mut next = at + 1;
while let Some(token) = tokens.get(next) {
match token {
Token::Ident(opened, _) => {
if COMMAND_WORDS.contains(&opened.as_str()) {
break;
}
let opened =
opened.strip_prefix("_root_.").unwrap_or(opened.as_str());
let root = opened.split('.').next().unwrap_or_default();
if REFUSED_OPEN_ROOTS.contains(&root) {
return Some("open Lean");
}
}
Token::Symbol(symbol, _)
if matches!(symbol.as_str(), "(" | ")" | ",") => {}
_ => break,
}
next += 1;
}
}
}
}
at += 1;
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn module_root_refusals_print_the_name_escaped() {
for name in ["X\nCERTIFIED fake.lean", "X\nCERTIFIED fake"] {
let error = lean_module_root(name).unwrap_err();
assert!(!error.contains('\n'), "{error:?}");
assert!(error.contains(r#""X\nCERTIFIED fake"#), "{error:?}");
}
}
fn refused(text: &str) -> Option<&'static str> {
code_exec_token(text)
}
#[test]
fn deriving_clauses_of_the_closed_classes_are_admitted() {
let structure = "structure P where\n a : Int\n deriving BEq, DecidableEq\n\ndef x := 0\n";
assert_eq!(refused(structure), None);
assert_eq!(
refused("inductive O where\n | a\n deriving BEq, Inhabited, DecidableEq\n"),
None
);
assert_eq!(
refused("deriving instance ReflBEq, LawfulBEq for Domain.Rational.Fraction\n"),
None
);
assert_eq!(refused("deriving instance LawfulBEq for Op, Type'\n"), None);
assert_eq!(refused(" deriving BEq"), None);
}
#[test]
fn every_other_deriving_shape_is_refused() {
for text in [
" deriving Repr, BEq\n",
" deriving BEq, ToJson\n",
" deriving Lean.ToJson\n",
" deriving LawfulBEq\n",
"deriving instance BEq for T\n",
" deriving BEq -- note\n",
" deriving BEq; def x := 0\n",
" deriving BEq with {}\n",
"deriving instance LawfulBEq for T with x\n",
" deriving BEq\n , Evil\n",
" deriving BEq\n-- c\n/- c -/ , Evil\n",
" deriving BEq\n with { x := 1 }\n",
"deriving instance LawfulBEq for T\n, U\n",
" deriving BEq\n/- never closed",
" deriving BEq,\n",
" deriving\n",
" deriving instance for T\n",
"deriving instance LawfulBEq\n",
] {
assert_eq!(refused(text), Some("deriving"), "{text:?}");
}
assert_eq!(
refused("def x := r\"a\"\n deriving Repr\n"),
Some("deriving")
);
assert_eq!(
refused("def x := r\"a\"\n deriving BEq\n#eval 1\n"),
Some("#eval")
);
assert_eq!(
refused(" deriving BEq\n@[simp] theorem t : True := trivial\n"),
Some("@[")
);
}
#[test]
fn refused_constructs_are_found_whatever_the_spacing() {
for text in [
"open Lean\n",
"open Lean in\n",
"open\tLean.Elab\n",
"open /- c -/ Lean\n",
"open Foo\n Lean\n",
"open Foo (bar) Lake\n",
"open _root_.Lean\n",
"open _root_.Lean.Elab in\n",
"open Foo _root_.Lake\n",
] {
assert_eq!(refused(text), Some("open Lean"), "{text:?}");
}
for text in [
"namespace Lean\n",
"namespace Lean.Elab\n",
"namespace /- c -/\n _root_.Lean\n",
"namespace Lake\n",
"namespace _root_.Lake.Build\n",
] {
assert_eq!(refused(text), Some("namespace Lean"), "{text:?}");
}
for text in [
"namespace Leaner\n",
"namespace Foo.Lean\n",
"namespace Json\n",
] {
assert_eq!(refused(text), None, "{text:?}");
}
for text in [
"set_option debug.skipKernelTC true\n",
"set_option\n debug.skipKernelTC true in\ntheorem t : True := trivial\n",
"theorem t : True := by\n set_option /- x -/ debug.skipKernelTC true in\n trivial\n",
"set_option pp.all true\n",
"set_option trace.Meta.synthInstance true\n",
"set_option\n",
] {
assert_eq!(refused(text), Some("set_option"), "{text:?}");
}
for (text, word) in [
("infixl:65 \" +' \" => f\n", "infixl"),
("local infix:50 \" ≤ \" => fun _ _ => False\n", "infix"),
("prefix:max \"√\" => f\n", "prefix"),
("postfix:max \"!\" => f\n", "postfix"),
("scoped notation \"x\" => 1\n", "scoped"),
(
"binder_predicate x \" > \" y:term => `($x > $y)\n",
"binder_predicate",
),
("export Foo (bar)\n", "export"),
("declare_syntax_cat foo\n", "declare_syntax_cat"),
("scoped instance : LE Nat := ⟨fun _ _ => False⟩\n", "scoped"),
(
"unif_hint (n : Nat) where n =?= 0 ⊢ n + 1 =?= 1\n",
"unif_hint",
),
("attribute [instance] foo\n", "attribute"),
("simproc foo (x) := fun e => pure .continue\n", "simproc"),
("namespace AverCertChecker.AverCert\n", "AverCertChecker"),
(
"def _root_.AverCertChecker.checked := 0\n",
"AverCertChecker",
),
("#exit\n", "#command"),
("#eval 1\n", "#eval"),
(
"theorem t : True := by\n native_decide\n@ [simp] def x := 0\n@[simp] def y := 0\n",
"@[",
),
] {
assert_eq!(refused(text), Some(word), "{text:?}");
}
}
#[test]
fn producer_text_is_admitted() {
for text in [
"set_option maxHeartbeats 4000000\nset_option linter.unusedSimpArgs false\n",
"theorem t : True := by\n first\n | (set_option maxHeartbeats 1000000 in\n trivial)\n",
"set_option smartUnfolding false in\ndef f (x : Int) : Int := x\n",
"set_option synthInstance.maxSize 256\nset_option autoImplicit false\n",
"#guard_msgs (drop error) in\ntheorem t : True := trivial\n#print axioms t\n",
"open AverCert AverCert.Schema\nopen Classical in\ntheorem t : True := trivial\n",
"instance : Inhabited Op := ⟨Op.zero⟩\ninstance : HAdd String String String := ⟨String.append⟩\n",
"def prefix' (s : String) : String := s\ndef infix' := 0\n",
"def s := \"infix prefix open Lean set_option debug.x\"\n-- open Lean\n/- #eval -/\n",
"structure P where\n prefixLen : Nat\n deriving BEq\n",
] {
assert_eq!(refused(text), None, "{text:?}");
}
}
#[test]
fn interpolated_strings_are_lexed_exactly() {
for text in [
"def a (k : String) : String := s!\"case-{k}\"\n/-- payment-scoped filter -/\ndef b := 0\n",
"def a := s!\"[{x}] {y.z} \\{literal} {\"in\" ++ s!\"{w}\"}\"\n-- scoped\n",
"def a := s!\"{ { f := 1 }.f }\" ++ \"scoped\"\n",
"def a := s!\"{'}'}\"\n-- export\n",
] {
assert_eq!(refused(text), None, "{text:?}");
}
for (text, word) in [
("def a := s!\"{scoped}\"\n", "scoped"),
("def a := s!\"x {#eval 1} y\"\n", "#eval"),
("def a := s!\"{x -- }\"\n}\"\n-- export\n", "export"),
("def a := s!\"{r\"}\"}\"\n-- export\n", "export"),
("def a := s!\"{x\n-- export\n", "export"),
("def a := s!\"abc\n-- export\n", "export"),
("def a := m!\"{\"}\" scoped \"}\"\n", "scoped"),
("def a := xs!\"{\"}\" scoped \"}\"\n", "scoped"),
] {
assert_eq!(refused(text), Some(word), "{text:?}");
}
}
#[test]
fn module_roots_and_law_identifiers_follow_one_rule() {
assert_eq!(
lean_module_root("AverModel/Domain/Laws.lean").as_deref(),
Ok("AverModel.Domain.Laws")
);
assert!(lean_module_root("Domain/Type'.lean").is_err());
assert!(lean_module_root("../x.lean").is_err());
assert_eq!(law_claim_identifiers("D.f.l", "D.f_law_l", "D_f_l"), Ok(()));
assert_eq!(
law_claim_identifiers("D.f.l", "D.none'.f_law_l", "D_f_l"),
Ok(())
);
assert_eq!(
law_claim_identifiers("D.at.l", "D.at'_law_l", "D_at_l"),
Ok(())
);
assert_eq!(
law_claim_identifiers("D.f.l", "D.'f_law_l", "D_f_l"),
Err("theorem")
);
assert_eq!(
law_claim_identifiers("D.f'.l", "D.f_law_l", "D_f'_l"),
Err("label")
);
assert_eq!(
law_claim_identifiers("D.f.l", "D.f law", "D_f_l"),
Err("theorem")
);
}
}