//! Platform regression guards checking source code for known defects and lifecycle hazards. use std::collections::{BTreeMap, BTreeSet}; use std::fmt; #[cfg(not(target_arch = "wasm32"))] use std::path::Path; use std::rc::Rc; /// A diagnostic finding reported by a source guard. #[derive(Debug, Clone, PartialEq, Eq)] pub struct Finding { /// File path where the violation was detected. pub path: String, /// 1-based line number of the violation. pub line: usize, /// Diagnostic context (the offending code snippet or float literal). pub text: String, } impl Finding { /// Create a new diagnostic finding. pub fn new(path: impl Into, line: usize, text: impl Into) -> Self { Self { path: path.into(), line, text: text.into() } } } impl fmt::Display for Finding { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.path.is_empty() { write!(f, "{}: {}", self.line, self.text) } else { write!(f, "{}:{}: {}", self.path, self.line, self.text) } } } /// Abstraction over a source file path and its text content. pub trait AsFileSource { /// Path of the source file. fn path(&self) -> &str; /// Text content of the source file. fn content(&self) -> &str; } impl AsFileSource for (String, String) { fn path(&self) -> &str { &self.0 } fn content(&self) -> &str { &self.1 } } impl AsFileSource for &(String, String) { fn path(&self) -> &str { &self.0 } fn content(&self) -> &str { &self.1 } } impl AsFileSource for (&str, &str) { fn path(&self) -> &str { self.0 } fn content(&self) -> &str { self.1 } } impl AsFileSource for &(&str, &str) { fn path(&self) -> &str { self.0 } fn content(&self) -> &str { self.1 } } impl AsFileSource for (String, &str) { fn path(&self) -> &str { &self.0 } fn content(&self) -> &str { self.1 } } impl AsFileSource for &(String, &str) { fn path(&self) -> &str { &self.0 } fn content(&self) -> &str { self.1 } } impl AsFileSource for (&str, String) { fn path(&self) -> &str { self.0 } fn content(&self) -> &str { &self.1 } } impl AsFileSource for &(&str, String) { fn path(&self) -> &str { self.0 } fn content(&self) -> &str { &self.1 } } /// The deepest `use` group nesting and `cfg` predicate nesting the guards follow. Deeper input is /// read as far as this depth, so hostile nesting cannot exhaust the stack. const MAX_NESTING: usize = 64; /// The most segments of a `use` path that [`use_leaves`] keeps. The guards compare paths of at most /// three segments, so a leaf with a longer path keeps only the name it binds, and a long prefix shared /// by many leaves is not copied into each of them. const MAX_USE_PATH: usize = 8; /// The longest segment, in bytes, of a `use` path that [`use_leaves`] keeps. The longest segment the /// guards compare is `PredefinedMenuItem`, so a leaf with a longer segment keeps only the name it binds, /// and a long name shared by many leaves is not copied into each of them. const MAX_USE_SEGMENT: usize = 32; /// The kind of a Rust token. Comments are dropped; string, character and number literals keep no text /// except the decoded contents of strings, which `cfg` predicates compare. A string with an escape /// that is not valid is `Other`. #[derive(Debug, Clone, PartialEq, Eq)] enum Kind { Ident(String), Punct(char), Str(String), Other, } #[derive(Debug, Clone)] struct Token { kind: Kind, line: usize, } impl Token { fn is_ident(&self, name: &str) -> bool { matches!(&self.kind, Kind::Ident(s) if s == name) } fn is_punct(&self, c: char) -> bool { self.kind == Kind::Punct(c) } } fn is_ident_start(c: char) -> bool { c == '_' || c.is_alphabetic() } fn is_ident_continue(c: char) -> bool { c == '_' || c.is_alphanumeric() } /// Split Rust source into tokens with 1-based line numbers. /// /// Line comments, nested block comments, string literals (normal, byte, C and raw strings with any /// number of `#`), character and byte literals, lifetimes and raw identifiers are recognized, so a quote /// or comment marker inside one of them does not hide the code after it. Unterminated literals and /// comments run to the end of the input. fn lex_rust(code: &str) -> Vec { let chars: Vec = code.chars().collect(); let len = chars.len(); let at = |i: usize| chars.get(i).copied(); let mut tokens = Vec::new(); let mut i = 0; let mut line = 1usize; while i < len { let c = chars[i]; if c == '\n' { line += 1; i += 1; } else if c.is_whitespace() { i += 1; } else if c == '/' && at(i + 1) == Some('/') { while i < len && chars[i] != '\n' { i += 1; } } else if c == '/' && at(i + 1) == Some('*') { let mut depth = 1usize; i += 2; while i < len && depth > 0 { if chars[i] == '/' && at(i + 1) == Some('*') { depth += 1; i += 2; } else if chars[i] == '*' && at(i + 1) == Some('/') { depth -= 1; i += 2; } else { if chars[i] == '\n' { line += 1; } i += 1; } } } else if is_ident_start(c) { let start = i; while i < len && is_ident_continue(chars[i]) { i += 1; } let word: String = chars[start..i].iter().collect(); let token_line = line; if matches!(word.as_str(), "r" | "br" | "cr") && matches!(at(i), Some('"' | '#')) { let mut j = i; while j < len && chars[j] == '#' { j += 1; } let hashes = j - i; if at(j) == Some('"') { let (end, text) = scan_raw_string(&chars, j + 1, hashes, &mut line); tokens.push(Token { kind: Kind::Str(text), line: token_line }); i = end; continue; } if word == "r" && hashes == 1 && at(j).is_some_and(is_ident_start) { let name_start = j; while j < len && is_ident_continue(chars[j]) { j += 1; } tokens.push(Token { kind: Kind::Ident(raw_identifier(&chars[name_start..j])), line: token_line }); i = j; continue; } } if matches!(word.as_str(), "b" | "c") && at(i) == Some('"') { let (end, kind) = scan_string(&chars, i + 1, &mut line); tokens.push(Token { kind, line: token_line }); i = end; continue; } if word == "b" && at(i) == Some('\'') && let Some(end) = char_literal_end(&chars, i) { tokens.push(Token { kind: Kind::Other, line: token_line }); i = end; continue; } tokens.push(Token { kind: Kind::Ident(word), line: token_line }); } else if c.is_ascii_digit() { while i < len && (is_ident_continue(chars[i]) || (chars[i] == '.' && at(i + 1).is_some_and(|d| d.is_ascii_digit()))) { i += 1; } tokens.push(Token { kind: Kind::Other, line }); } else if c == '"' { let token_line = line; let (end, kind) = scan_string(&chars, i + 1, &mut line); tokens.push(Token { kind, line: token_line }); i = end; } else if c == '\'' { if let Some(end) = char_literal_end(&chars, i) { i = end; } else { // A lifetime or a loop label. i += 1; while i < len && is_ident_continue(chars[i]) { i += 1; } } tokens.push(Token { kind: Kind::Other, line }); } else { tokens.push(Token { kind: Kind::Punct(c), line }); i += 1; } } tokens } /// The name of a raw identifier written after `r#`. A raw identifier spelled like a keyword the guards /// read (`r#let`, `r#in`, `r#match`, `r#true`) keeps its prefix, so it is read as a name rather than as /// that keyword or as a `cfg` literal. fn raw_identifier(name: &[char]) -> String { let name: String = name.iter().collect(); let keyword = |list: &[&str]| list.contains(&name.as_str()); if keyword(&["true", "false"]) || keyword(KEYWORDS) || keyword(BLOCK_KEYWORDS) || keyword(VALUE_KEYWORDS) { format!("r#{name}") } else { name } } /// Read a normal string body starting after its opening quote. Returns the index after the closing /// quote and the token for the body: `Str` with its escapes decoded, or `Other` when an escape is not /// valid in a string. fn scan_string(chars: &[char], mut i: usize, line: &mut usize) -> (usize, Kind) { let mut text = Some(String::new()); while i < chars.len() { match chars[i] { '\\' => { let (next, decoded) = string_escape(chars, i + 1, line); match decoded { Ok(Some(c)) => text.iter_mut().for_each(|t| t.push(c)), Ok(None) => {} Err(()) => text = None, } i = next; } '"' => return (i + 1, text.map_or(Kind::Other, Kind::Str)), c => { if c == '\n' { *line += 1; } text.iter_mut().for_each(|t| t.push(c)); i += 1; } } } (chars.len(), text.map_or(Kind::Other, Kind::Str)) } /// Decode the string escape whose `\` is right before `chars[i]` /// (). Returns the index after the /// escape and the character it stands for, `None` for a line continuation, or an error when it is not /// a valid escape. fn string_escape(chars: &[char], i: usize, line: &mut usize) -> (usize, Result, ()>) { let hex = |k: usize| chars.get(k).and_then(|c| c.to_digit(16)); match chars.get(i) { Some('n') => (i + 1, Ok(Some('\n'))), Some('r') => (i + 1, Ok(Some('\r'))), Some('t') => (i + 1, Ok(Some('\t'))), Some('0') => (i + 1, Ok(Some('\0'))), Some(&c @ ('\\' | '\'' | '"')) => (i + 1, Ok(Some(c))), Some('x') => match (hex(i + 1), hex(i + 2)) { (Some(high), Some(low)) if high < 8 => (i + 3, Ok(char::from_u32(high * 16 + low))), _ => (i + 1, Err(())), }, Some('u') if chars.get(i + 1) == Some(&'{') => { // At most six hex digits, with underscores, before the closing brace. let mut value = 0u32; let mut digits = 0; let mut j = i + 2; while let Some(&c) = chars.get(j) { if c == '}' { break; } if c != '_' { match c.to_digit(16) { Some(d) if digits < 6 => { value = value * 16 + d; digits += 1; } _ => return (j, Err(())), } } j += 1; } match (chars.get(j), char::from_u32(value)) { (Some('}'), Some(c)) if digits > 0 && chars.get(i + 2) != Some(&'_') => (j + 1, Ok(Some(c))), _ => (j.min(chars.len()), Err(())), } } Some('\n') => { // A line continuation skips the line break and the whitespace after it. let mut j = i; while let Some(&c) = chars.get(j).filter(|c| matches!(c, ' ' | '\t' | '\n' | '\r')) { if c == '\n' { *line += 1; } j += 1; } (j, Ok(None)) } Some('\r') if chars.get(i + 1) == Some(&'\n') => { let (j, _) = string_escape(chars, i + 1, line); (j, Ok(None)) } Some(_) => (i + 1, Err(())), None => (i, Err(())), } } /// Read a raw string body starting after its opening quote; it ends at a quote followed by `hashes` `#`. fn scan_raw_string(chars: &[char], mut i: usize, hashes: usize, line: &mut usize) -> (usize, String) { let start = i; while i < chars.len() { if chars[i] == '"' && (1..=hashes).all(|h| chars.get(i + h) == Some(&'#')) { return (i + 1 + hashes, chars[start..i].iter().collect()); } if chars[i] == '\n' { *line += 1; } i += 1; } (chars.len(), chars[start.min(chars.len())..].iter().collect()) } /// The index after a character or byte literal whose opening quote is at `quote`, or `None` when the /// quote starts a lifetime or a label. fn char_literal_end(chars: &[char], quote: usize) -> Option { match chars.get(quote + 1) { Some('\\') => { // An escape: `\n`, `\'`, `\x7f`, `\u{10FFFF}`. The longest is twelve characters. let mut j = quote + 3; while j < chars.len() && j <= quote + 12 && chars[j] != '\'' && chars[j] != '\n' { j += 1; } (chars.get(j) == Some(&'\'')).then_some(j + 1) } Some('\n') | None => None, Some(_) => (chars.get(quote + 2) == Some(&'\'')).then_some(quote + 3), } } /// Rust keywords that can come right before a path that starts with `::`, as in `return ::std::time`. /// `crate`, `self`, `super` and `Self` are path segments and are not listed. const KEYWORDS: &[&str] = &[ "as", "async", "await", "box", "break", "const", "continue", "dyn", "else", "enum", "extern", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return", "static", "struct", "trait", "type", "unsafe", "use", "where", "while", "yield", ]; /// Whether `toks[i]` follows `::` that itself follows a path segment, as `time` does in `a::time`. /// The `>` of `->` and `=>` ends no path, so `-> ::std::time` starts one. fn continues_a_path(toks: &[Token], i: usize) -> bool { i >= 3 && toks[i - 1].is_punct(':') && toks[i - 2].is_punct(':') && match &toks[i - 3].kind { Kind::Ident(s) => !KEYWORDS.contains(&s.as_str()), Kind::Punct('>') => !(i >= 4 && (toks[i - 4].is_punct('-') || toks[i - 4].is_punct('='))), _ => false, } } /// Whether `toks[i..]` starts with `::` followed by the identifier `name`. fn then_path(toks: &[Token], i: usize, name: impl Fn(&str) -> bool) -> bool { toks.get(i).is_some_and(|t| t.is_punct(':')) && toks.get(i + 1).is_some_and(|t| t.is_punct(':')) && toks.get(i + 2).is_some_and(|t| matches!(&t.kind, Kind::Ident(s) if name(s))) } /// Whether the path that ends at `toks[i]` starts right after the `<` of a qualified path, as in /// `::quit`, rather than after the `<` of generic arguments (`Vec::new`, /// `f::`). fn opens_qualified_path(toks: &[Token], i: usize) -> bool { let mut start = i; while start >= 2 && toks[start - 1].is_punct(':') && toks[start - 2].is_punct(':') { if start >= 3 && matches!(toks[start - 3].kind, Kind::Ident(_)) { start -= 3; } else { start -= 2; break; } } start >= 1 && toks[start - 1].is_punct('<') && match start.checked_sub(2).map(|j| &toks[j].kind) { None => true, Some(Kind::Ident(s)) => KEYWORDS.contains(&s.as_str()), Some(Kind::Punct(c)) => !matches!(*c, ':' | '>'), Some(_) => false, } } /// One name a `use` declaration brings into scope. #[derive(Debug)] struct UseLeaf { /// The full path, `self` removed and without a leading `::`. It is empty for a path longer than /// [`MAX_USE_PATH`] segments or with a segment longer than [`MAX_USE_SEGMENT`] bytes, whose leaf then /// records only the name it binds. path: Vec, /// The name it is bound to, `_` for an underscore import; `None` for a glob import. The name is /// shared with the other leaves that bind the same segment of one path. name: Option>, /// The first segment of the path, kept when the path is not. root: Option>, line: usize, /// Index of the `use` keyword. start: usize, /// Index of the alias of `std::time` that the path was read through, when [`use_leaves`] was given one. alias: Option, /// Whether the path starts with `::`, so that its first segment names an external crate. absolute: bool, } impl UseLeaf { /// The name the leaf binds in scope: `None` for a glob import and for an underscore import, which /// imports an item without binding a name. fn binding(&self) -> Option<&str> { self.name.as_deref().filter(|name| *name != "_") } } /// Every name the `use` declarations of a file bring into scope. A path that starts with a name in /// `time_aliases` is read as a path that starts with `std::time`, so the alias, at any length, is not /// copied into the leaves and the limits do not drop them. fn use_leaves(toks: &[Token], time_aliases: &BTreeSet) -> Vec { let mut leaves = Vec::new(); let mut i = 0; while i < toks.len() { // `use<...>` is a precise capturing bound on `impl Trait`, not a `use` declaration. if toks[i].is_ident("use") && !continues_a_path(toks, i) && !toks.get(i + 1).is_some_and(|t| t.is_punct('<')) { let start = i; let end = (i + 1..toks.len()).find(|&j| toks[j].is_punct(';')).unwrap_or(toks.len()); let mut pos = i + 1; let mut prefix = Vec::new(); parse_use_tree(&toks[..end], &mut pos, &mut prefix, (start, None, false), &mut leaves, time_aliases, 0); i = end; } else { i += 1; } } leaves } fn parse_use_tree( toks: &[Token], pos: &mut usize, prefix: &mut Vec>, // The index of the `use` keyword, the alias of `std::time` that `prefix` was read through, and whether // the path starts with `::`. (start, mut via, mut absolute): (usize, Option, bool), out: &mut Vec, time_aliases: &BTreeSet, depth: usize, ) { let base = prefix.len(); if toks.get(*pos).is_some_and(|t| t.is_punct(':')) && toks.get(*pos + 1).is_some_and(|t| t.is_punct(':')) { absolute |= prefix.is_empty(); *pos += 2; } // A leaf is reported on the line where its path starts in this tree, not where its last name is. let line = toks.get(*pos).map_or(0, |t| t.line); while let Some(tok) = toks.get(*pos) { match &tok.kind { Kind::Ident(name) => { *pos += 1; if toks.get(*pos).is_some_and(|t| t.is_punct(':')) && toks.get(*pos + 1).is_some_and(|t| t.is_punct(':')) { if prefix.is_empty() && time_aliases.contains(name) { prefix.extend([Rc::from("std"), Rc::from("time")]); via = Some(*pos - 1); } else { prefix.push(Rc::from(name.as_str())); } *pos += 2; continue; } let length = prefix.len() + usize::from(name != "self"); let alias = match (toks.get(*pos), toks.get(*pos + 1).map(|t| &t.kind)) { (Some(t), Some(Kind::Ident(alias))) if t.is_ident("as") => { *pos += 2; Some(alias) } _ => None, }; // The name the leaf binds: its alias, its last name, or for `self` the last segment of // the prefix, shared rather than copied. let bound = match alias { Some(alias) => Some(Rc::from(alias.as_str())), None if name != "self" => Some(Rc::from(name.as_str())), None => prefix.last().cloned(), }; // A path past the limits is not copied, but the leaf still binds its name, so that the name // does not read as unbound. let path = if length <= MAX_USE_PATH && short_segments(prefix) && name.len() <= MAX_USE_SEGMENT { let mut path: Vec = prefix.iter().map(|segment| segment.to_string()).collect(); if name != "self" { path.push(name.clone()); } path } else { Vec::new() }; if bound.is_some() { let root = prefix.first().cloned().or_else(|| Some(Rc::from(name.as_str()))); out.push(UseLeaf { path, name: bound, root, line, start, alias: via, absolute }); } break; } Kind::Punct('*') => { if prefix.len() <= MAX_USE_PATH && short_segments(prefix) { let path = prefix.iter().map(|segment| segment.to_string()).collect(); out.push(UseLeaf { path, name: None, root: prefix.first().cloned(), line, start, alias: via, absolute }); } *pos += 1; break; } Kind::Punct('{') => { *pos += 1; while let Some(t) = toks.get(*pos) { if t.is_punct('}') { *pos += 1; break; } let before = *pos; if !t.is_punct(',') && depth < MAX_NESTING { parse_use_tree(toks, pos, prefix, (start, via, absolute), out, time_aliases, depth + 1); } if *pos == before { *pos += 1; } } break; } _ => break, } } prefix.truncate(base); } /// Whether every segment of `path` is at most [`MAX_USE_SEGMENT`] bytes long. fn short_segments(path: &[Rc]) -> bool { path.iter().all(|segment| segment.len() <= MAX_USE_SEGMENT) } /// A value of a `cfg` predicate on `wasm32-unknown-unknown`, where the value of a feature or of /// `test` is not known from the source. #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum Tri { True, False, Unknown, } impl Tri { fn from_bool(b: bool) -> Self { if b { Self::True } else { Self::False } } fn not(self) -> Self { match self { Self::True => Self::False, Self::False => Self::True, Self::Unknown => Self::Unknown, } } } /// Evaluate the `cfg` predicate at `toks[*pos]` for `wasm32-unknown-unknown`. fn eval_cfg(toks: &[Token], pos: &mut usize, depth: usize) -> Tri { let Some(Kind::Ident(name)) = toks.get(*pos).map(|t| &t.kind) else { return Tri::Unknown; }; *pos += 1; if toks.get(*pos).is_some_and(|t| t.is_punct('=')) { let value = match toks.get(*pos + 1).map(|t| &t.kind) { Some(Kind::Str(v)) => v.clone(), _ => return Tri::Unknown, }; *pos += 2; let expected = match name.as_str() { "target_arch" => "wasm32", "target_os" | "target_vendor" => "unknown", "target_family" => "wasm", "target_env" => "", "target_pointer_width" => "32", "target_endian" => "little", _ => return Tri::Unknown, }; return Tri::from_bool(value == expected); } if toks.get(*pos).is_some_and(|t| t.is_punct('(')) { if depth >= MAX_NESTING { // Too deep to read: the predicate is skipped as a whole, and its value is not known. *pos = matching_close(toks, *pos).saturating_add(1); return Tri::Unknown; } *pos += 1; let mut values = Vec::new(); while let Some(t) = toks.get(*pos) { if t.is_punct(')') { *pos += 1; break; } if t.is_punct(',') { *pos += 1; continue; } let before = *pos; values.push(eval_cfg(toks, pos, depth + 1)); if *pos == before { *pos += 1; } } return match name.as_str() { "not" => values.first().map_or(Tri::Unknown, |v| v.not()), "all" if values.contains(&Tri::False) => Tri::False, "all" if values.contains(&Tri::Unknown) => Tri::Unknown, "all" => Tri::True, "any" if values.contains(&Tri::True) => Tri::True, "any" if values.contains(&Tri::Unknown) => Tri::Unknown, "any" => Tri::False, _ => Tri::Unknown, }; } match name.as_str() { "unix" | "windows" | "false" => Tri::False, "true" => Tri::True, _ => Tri::Unknown, } } /// The index of the token that closes the bracket opened at `open`, or `toks.len()`. fn matching_close(toks: &[Token], open: usize) -> usize { let mut depth = 0usize; for (j, t) in toks.iter().enumerate().skip(open) { match t.kind { Kind::Punct('(' | '[' | '{') => depth += 1, Kind::Punct(')' | ']' | '}') => { depth = depth.saturating_sub(1); if depth == 0 { return j; } } _ => {} } } toks.len() } /// Keywords whose item or expression ends with its closing brace rather than with `;`. const BLOCK_KEYWORDS: &[&str] = &["fn", "mod", "impl", "trait", "struct", "enum", "union", "extern", "macro_rules", "if", "match", "loop", "while", "for", "unsafe"]; /// Keywords that start a statement whose value follows them, so a block keyword after them is part of /// that value. const VALUE_KEYWORDS: &[&str] = &["let", "return", "break", "yield", "become"]; /// Where [`item_end`] is in the head of an `if`, `while`, `match` or `for` before its body's `{`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum Condition { /// Not in such a head: the next `{` outside brackets opens the body. Done, /// In the pattern of a `let` or a `for`, where a `{` opens a struct pattern. Pattern, /// In a condition, a scrutinee or an iterator, where the next `{` outside brackets opens the body. Expression, } /// Whether the `=` at `toks[j]` stands alone, as the `=` between a `let` pattern and its value, rather /// than as part of `==`, `!=`, `<=`, `>=`, `=>` or the range pattern `..=`. fn lone_equals(toks: &[Token], j: usize) -> bool { let punct = |k: usize, cs: &[char]| toks.get(k).is_some_and(|t| cs.iter().any(|&c| t.is_punct(c))); !punct(j + 1, &['=', '>']) && j.checked_sub(1).is_none_or(|k| !punct(k, &['=', '!', '<', '>', '.'])) } /// Whether a block expression starts at `j`: `{`, a labeled block (`'label: {`) or a `const` block. fn starts_block(toks: &[Token], j: usize) -> bool { let punct = |k: usize, c: char| toks.get(k).is_some_and(|t| t.is_punct(c)); match toks.get(j).map(|t| &t.kind) { Some(Kind::Punct('{')) => true, Some(Kind::Other) => punct(j + 1, ':') && punct(j + 2, '{'), Some(Kind::Ident(k)) => k == "const" && punct(j + 1, '{'), _ => false, } } /// Whether the `{` at `toks[j]`, in the condition, scrutinee or iterator of an `if`, `while`, `match` or /// `for`, stands where an operand is still needed, so it opens a block expression rather than the body: /// right after the keyword, after `in`, after the `=` of a `let`, after an operator or `!`, after /// `unsafe`, `const`, `loop`, `async` or `async move`, or after a loop label's `:`. fn operand_expected(toks: &[Token], j: usize) -> bool { let Some(k) = j.checked_sub(1) else { return false }; match &toks[k].kind { Kind::Ident(prev) => matches!(prev.as_str(), "if" | "while" | "match" | "in" | "unsafe" | "const" | "loop" | "async" | "move"), Kind::Punct('=' | '+' | '-' | '*' | '/' | '%' | '^' | '|' | '&' | '<' | '>' | '!') => true, Kind::Punct(':') => k.checked_sub(1).is_some_and(|l| toks[l].kind == Kind::Other), _ => false, } } /// The index after the item, statement, field or match arm that starts at `start`, or with `inner`, the /// index of the bracket that closes the enclosing scope. /// /// It ends after a `;` or a `,` outside brackets, after the closing brace of a block item, or before a /// closing bracket of the enclosing scope. A block item starts with `{`, a labeled block, a `const` /// block, a keyword in [`BLOCK_KEYWORDS`] or a macro call with braces, at the head of the item or of a /// match arm's body (after its `=>`). An `async` block is not a block item: it runs on to its `;`. A /// block keyword or macro brace after a `=`, a binary operator or a keyword in [`VALUE_KEYWORDS`] /// outside brackets is part of an expression, which runs on to its `;` or `,`. When a `.` or `?` /// follows the closing brace of a block item, the item runs on to its `;` or `,`. A `,` inside the angle /// brackets of a field's or a `let`'s type ends the item early, which leaves the rest of it checked. /// /// The body of an `if`, `while`, `match` or `for` at the head is the first `{` outside brackets after its /// condition, scrutinee or iterator. A `{` where the condition still needs an operand (see /// [`operand_expected`]) opens a block expression in it, as in `if { ready() } { ... }`, and the body is /// the next `{` after that block. A `{` in the pattern of a `let` (`if let S { .. } = s`, also after /// `&&` in a chain) or of a `for` opens a struct pattern and does not end the item. An `else` chain ends /// at its last block. /// /// In the head of an `fn`, `impl`, `trait`, `struct`, `enum` or `union` item, a block inside angle /// brackets (a const generic default or argument such as ``, also in a /// return type or a `where` clause) does not end the item. The `>` of `->` does not close an angle /// bracket. fn item_end(toks: &[Token], start: usize, inner: bool) -> usize { let mut depth = 0usize; let mut block_item = false; let mut arm = false; let mut head = true; let mut condition = Condition::Done; let mut generics = false; let mut angle = 0usize; let mut j = start; while j < toks.len() { let at_top = depth == 0 && !inner; if j == start && at_top && starts_block(toks, j) { block_item = true; } match &toks[j].kind { Kind::Ident(k) if at_top && head && (BLOCK_KEYWORDS.contains(&k.as_str()) || starts_block(toks, j)) => { if !block_item { condition = match k.as_str() { "if" | "while" | "match" => Condition::Expression, "for" => Condition::Pattern, _ => Condition::Done, }; } if matches!(k.as_str(), "fn" | "impl" | "trait" | "struct" | "enum" | "union") { generics = true; } block_item = true; } Kind::Punct('<') if at_top && generics => angle += 1, Kind::Punct('>') if at_top && generics && !j.checked_sub(1).is_some_and(|k| toks[k].is_punct('-')) => { angle = angle.saturating_sub(1); } Kind::Ident(k) if at_top && condition == Condition::Expression && k == "let" => condition = Condition::Pattern, Kind::Ident(k) if at_top && condition == Condition::Pattern && k == "in" => condition = Condition::Expression, Kind::Punct('=') if at_top && condition == Condition::Pattern && lone_equals(toks, j) => condition = Condition::Expression, Kind::Punct('{') if at_top && condition == Condition::Expression => { // A `{` where the condition still needs an operand opens a block expression inside it // (`if { ready() } { ... }`); the body's `{` comes after the condition's last operand. if !operand_expected(toks, j) { condition = Condition::Done; } depth += 1; } Kind::Ident(k) if at_top && VALUE_KEYWORDS.contains(&k.as_str()) => head = false, Kind::Punct('!') if at_top && head && toks.get(j + 1).is_some_and(|t| t.is_punct('{')) => block_item = true, Kind::Punct('=') if at_top && toks.get(j + 1).is_some_and(|t| t.is_punct('>')) => { // A match arm's body has a head of its own: a block or block keyword there ends the arm. arm = true; head = true; block_item = starts_block(toks, j + 2); condition = Condition::Done; j += 2; continue; } // The `:` after a field's or a static's name starts its type, where `fn` is a function pointer // type rather than an item. The `:` of a path (`::`) and the one after a loop label are not. Kind::Punct(':') if at_top && !block_item && !toks.get(j + 1).is_some_and(|t| t.is_punct(':')) && j.checked_sub(1).is_none_or(|k| !toks[k].is_punct(':') && toks[k].kind != Kind::Other) => { head = false; } Kind::Punct('=' | '+' | '-' | '*' | '/' | '%' | '^' | '|' | '&' | '<' | '>' | '!') if at_top && !block_item => head = false, Kind::Punct('(' | '[' | '{') => depth += 1, Kind::Punct(c @ (')' | ']' | '}')) => { if depth == 0 { return j; } depth -= 1; if depth == 0 && *c == '}' && block_item && !inner && condition == Condition::Done && angle == 0 { if toks.get(j + 1).is_some_and(|t| t.is_ident("else")) { // `else if` has a condition of its own before its body; `else {` opens the body. if toks.get(j + 2).is_some_and(|t| t.is_ident("if")) { condition = Condition::Expression; } j += 1; continue; } if toks.get(j + 1).is_some_and(|t| t.is_punct('.') || t.is_punct('?')) { // A method call, field or `?` after the block continues the expression to its `;` or `,`. block_item = false; head = false; j += 1; continue; } let comma = toks.get(j + 1).is_some_and(|t| t.is_punct(',')); return if arm && comma { j + 2 } else { j + 1 }; } } Kind::Punct(';') if at_top => return j + 1, Kind::Punct(',') if at_top && (arm || !block_item) => return j + 1, _ => {} } j += 1; } toks.len() } /// Mark the tokens of every item whose `cfg` attribute is false on `wasm32-unknown-unknown`. /// /// An outer attribute (`#[cfg(...)]`) covers the item after it; an inner attribute (`#![cfg(...)]`) /// covers the rest of the module or block it is in. fn native_only(toks: &[Token]) -> Vec { cfg_covered(toks, false) } /// Mark the tokens of every item that a `cfg` attribute covers: with `any`, whatever its predicate, /// otherwise only when the predicate is false on `wasm32-unknown-unknown`, as [`native_only`] does. fn cfg_covered(toks: &[Token], any: bool) -> Vec { let mut skip = vec![false; toks.len()]; let mut i = 0; while i < toks.len() { if !toks[i].is_punct('#') { i += 1; continue; } let inner = toks.get(i + 1).is_some_and(|t| t.is_punct('!')); let open = if inner { i + 2 } else { i + 1 }; if !toks.get(open).is_some_and(|t| t.is_punct('[')) { i += 1; continue; } let close = matching_close(toks, open); if close >= toks.len() { // An unclosed attribute: no later bracket closes it, so nothing after it is an item. break; } let excluded = toks.get(open + 1).is_some_and(|t| t.is_ident("cfg")) && toks.get(open + 2).is_some_and(|t| t.is_punct('(')) && { let mut pos = open + 3; any || eval_cfg(&toks[..close], &mut pos, 0) == Tri::False }; if !excluded { i = close + 1; continue; } // Further outer attributes on the same item. let mut item = close + 1; while !inner && item < toks.len() && toks[item].is_punct('#') && toks.get(item + 1).is_some_and(|t| t.is_punct('[')) { item = matching_close(toks, item + 1).saturating_add(1); } let end = item_end(toks, item.min(toks.len()), inner); for s in skip.iter_mut().take(end).skip(i) { *s = true; } i = end.max(i + 1); } skip } /// The index of the keyword of every item that carries an outer `cfg` attribute of its own whose predicate /// is not known to be true on `wasm32-unknown-unknown`, so the item may be absent from the web build: the /// token after the item's outer attributes and its visibility (`pub`, `pub(...)`). fn cfg_items(toks: &[Token]) -> BTreeSet { let mut items = BTreeSet::new(); let mut i = 0; while i < toks.len() { let cfg = toks[i].is_punct('#') && toks.get(i + 1).is_some_and(|t| t.is_punct('[')) && toks.get(i + 2).is_some_and(|t| t.is_ident("cfg")) && toks.get(i + 3).is_some_and(|t| t.is_punct('(')); if !cfg { i += 1; continue; } let close = matching_close(toks, i + 1); if close >= toks.len() { break; } let mut pos = i + 4; if eval_cfg(&toks[..close], &mut pos, 0) == Tri::True { i = close + 1; continue; } let mut item = close + 1; while item < toks.len() && toks[item].is_punct('#') && toks.get(item + 1).is_some_and(|t| t.is_punct('[')) { item = matching_close(toks, item + 1).saturating_add(1); } if toks.get(item).is_some_and(|t| t.is_ident("pub")) { item += 1; if toks.get(item).is_some_and(|t| t.is_punct('(')) { item = matching_close(toks, item).saturating_add(1); } } if item < toks.len() { items.insert(item); } i = item.max(i + 1); } items } /// A module declaration, `mod name;` or the head of `mod name { ... }`. #[derive(Debug, Clone)] struct ModName { name: String, /// The string of a `#[path = "..."]` attribute on the declaration. path_attribute: Option, } /// An out-of-line module declaration, `mod name;`. #[derive(Debug)] struct ModDecl { module: ModName, /// The inline modules (`mod a { ... }`) the declaration is inside, outermost first, shared between the /// declarations inside them. inline: Vec>, /// Whether the declaration is inside an item whose `cfg` is false on `wasm32-unknown-unknown`. native: bool, } /// The most tokens [`path_attribute`] reads back from one `mod` keyword, so that hostile nesting cannot /// make the scan quadratic. const ATTRIBUTE_SCAN_LIMIT: usize = 4096; /// The index of the bracket `open` that matches the bracket `close` at `toks[end - 1]`, reading back /// from `end`, or `None` when it is not found within `budget` tokens. fn matching_open_back(toks: &[Token], end: usize, open: char, close: char, budget: &mut usize) -> Option { let mut depth = 0usize; let mut j = end; while j > 0 && *budget > 0 { j -= 1; *budget -= 1; if toks[j].is_punct(close) { depth += 1; } else if toks[j].is_punct(open) { depth = depth.saturating_sub(1); if depth == 0 { return Some(j); } } } None } /// The string of a `#[path = "..."]` outer attribute on the item whose `mod` keyword is at `toks[m]`. fn path_attribute(toks: &[Token], m: usize) -> Option { let mut budget = ATTRIBUTE_SCAN_LIMIT; let mut k = m; if k > 0 && toks[k - 1].is_punct(')') { // A visibility such as `pub(crate)`. let j = matching_open_back(toks, k, '(', ')', &mut budget)?; if j > 0 && toks[j - 1].is_ident("pub") { k = j - 1; } } else if k > 0 && toks[k - 1].is_ident("pub") { k -= 1; } let mut found = None; while k > 0 && toks[k - 1].is_punct(']') { let Some(j) = matching_open_back(toks, k, '[', ']', &mut budget) else { break }; if j == 0 || !toks[j - 1].is_punct('#') { break; } if toks.get(j + 1).is_some_and(|t| t.is_ident("path")) && toks.get(j + 2).is_some_and(|t| t.is_punct('=')) && let Some(Kind::Str(s)) = toks.get(j + 3).map(|t| &t.kind) { found = Some(s.clone()); } k = j - 1; } found } /// What an open brace in [`module_decls`] opened. #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum Brace { /// A block that is not an inline module. Block, /// An inline module, pushed on the inline stack. Module, /// An inline module deeper than [`MAX_NESTING`], not tracked. TooDeep, } /// The name of a module's file or folder: a raw identifier such as `r#match` names `match`. fn module_name(name: &str) -> String { name.strip_prefix("r#").unwrap_or(name).to_owned() } /// Every out-of-line module declaration in a file, in one pass that tracks the inline modules around it. /// /// Declarations inside more than [`MAX_NESTING`] inline modules are left out, so their files are checked. fn module_decls(toks: &[Token], skip: &[bool]) -> Vec { let mut decls = Vec::new(); let mut braces: Vec = Vec::new(); let mut inline: Vec> = Vec::new(); let mut too_deep = 0usize; for (i, tok) in toks.iter().enumerate() { match &tok.kind { Kind::Punct('{') => { let brace = match i.checked_sub(2).map(|j| (&toks[j], &toks[j + 1].kind)) { Some((m, Kind::Ident(name))) if m.is_ident("mod") => { if too_deep == 0 && inline.len() < MAX_NESTING { inline.push(Rc::new(ModName { name: module_name(name), path_attribute: path_attribute(toks, i - 2) })); Brace::Module } else { too_deep += 1; Brace::TooDeep } } _ => Brace::Block, }; braces.push(brace); } Kind::Punct('}') => match braces.pop() { Some(Brace::Module) => { inline.pop(); } Some(Brace::TooDeep) => too_deep -= 1, _ => {} }, Kind::Ident(k) if k == "mod" && too_deep == 0 => { if let Some(Kind::Ident(name)) = toks.get(i + 1).map(|t| &t.kind) && toks.get(i + 2).is_some_and(|t| t.is_punct(';')) { decls.push(ModDecl { module: ModName { name: module_name(name), path_attribute: path_attribute(toks, i) }, inline: inline.clone(), native: skip.get(i).copied().unwrap_or(false), }); } } _ => {} } } decls } /// A path with `\` read as `/`, empty and `.` components removed and `..` applied to the component before it. fn normalize_path(path: &str) -> String { let path = path.replace('\\', "/"); let absolute = path.starts_with('/'); let mut parts: Vec<&str> = Vec::new(); for part in path.split('/') { match part { "" | "." => {} ".." if parts.last().is_some_and(|p| *p != "..") => { parts.pop(); } p => parts.push(p), } } let joined = parts.join("/"); if absolute { format!("/{joined}") } else { joined } } /// `child` below the folder `parent`, normalized. A `child` that is an absolute path (`/x`, `\x` or `C:...`) /// stands alone. `\\` is read as one separator, since a string literal keeps its escapes. fn join_path(parent: &str, child: &str) -> String { let child = child.replace("\\\\", "/"); if parent.is_empty() || child.starts_with('/') || child.starts_with('\\') || child.as_bytes().get(1) == Some(&b':') { normalize_path(&child) } else { normalize_path(&format!("{parent}/{child}")) } } /// The paths, normalized, where the module `decl` declared in the file at `parent` (normalized) can be. /// /// The modules of `lib.rs`, `main.rs` and `mod.rs`, and with `path_loaded`, of a file that a `#[path]` /// attribute names, are in the file's folder, and those of any other file are in the folder named after /// its stem. Each inline module around the declaration adds a folder named /// after it, or with a `path` attribute, moves to that path relative to the current folder (without the /// stem folder). The module is then `.rs` or `/mod.rs` there, or with a `path` attribute, that /// path relative to the current folder, again without the stem folder. fn module_files(parent: &str, decl: &ModDecl, path_loaded: bool) -> Vec { let (dir, file) = match parent.rsplit_once('/') { Some(("", file)) => ("/", file), Some(split) => split, None => ("", parent), }; let mut folder = dir.to_string(); let mut stem = (!path_loaded && !matches!(file, "lib.rs" | "main.rs" | "mod.rs")).then(|| file.strip_suffix(".rs").unwrap_or(file)); for inline in &decl.inline { if let Some(attr) = &inline.path_attribute { folder = join_path(&folder, attr); stem = None; } else { if let Some(stem) = stem.take() { folder = join_path(&folder, stem); } folder = join_path(&folder, &inline.name); } } if let Some(attr) = &decl.module.path_attribute { return vec![join_path(&folder, attr)]; } if let Some(stem) = stem { folder = join_path(&folder, stem); } let name = &decl.module.name; vec![join_path(&folder, &format!("{name}.rs")), join_path(&folder, &format!("{name}/mod.rs"))] } /// For each file, whether it is native-only: a `mod` declaration in a native-only item, or any declaration /// in a native-only file, names it, and no chain of declarations outside native-only items reaches it from /// a crate root (a file that no declaration names, or in a cycle of declarations that no file outside the /// cycle names, its `lib.rs` or `main.rs`, or every member when it has neither). fn native_only_files(paths: &[String], decls: &[Vec]) -> Vec { let mut index: BTreeMap<&str, Vec> = BTreeMap::new(); for (i, path) in paths.iter().enumerate() { index.entry(path.as_str()).or_default().push(i); } // rustc reads a file that a `#[path]` attribute names as if it were a `mod.rs`, so the modules it // declares are in its own folder rather than its stem folder. Each file is therefore two nodes: node // `2 * file` for the file loaded by a plain `mod name;` (or as a crate root), and node `2 * file + 1` // for the file loaded through a `#[path]` attribute. Each node lists the nodes its declarations name, // with whether the declaration is in a native-only item. let edges: Vec> = (0..paths.len() * 2) .map(|node| { let (parent, path_loaded) = (node / 2, node % 2 == 1); let mut targets = Vec::new(); for decl in &decls[parent] { let by_path = usize::from(decl.module.path_attribute.is_some()); for candidate in module_files(&paths[parent], decl, path_loaded) { for &j in index.get(candidate.as_str()).into_iter().flatten() { targets.push((decl.native, 2 * j + by_path)); } } } targets }) .collect(); // A group of files that name each other in a cycle, and that no file outside the group names, has no // member that a crate root can reach. rustc does not load a cycle of enabled declarations, so such a // cycle runs through a declaration the build leaves out. When the group holds a `lib.rs` or `main.rs`, // those files are its crate roots and the declarations that name them are read as left out; otherwise // no declaration of the group names its own members, and each of them can be a crate root. let file_edges: Vec> = (0..paths.len()).map(|file| edges[2 * file].iter().chain(&edges[2 * file + 1]).map(|&(_, target)| target / 2).collect()).collect(); let component = components(&file_edges); let root_file = |file: usize| matches!(paths[file].rsplit('/').next(), Some("lib.rs" | "main.rs")); let mut entered = vec![false; paths.len()]; let mut has_root = vec![false; paths.len()]; for (file, targets) in file_edges.iter().enumerate() { has_root[component[file]] |= root_file(file); for &target in targets { if component[target] != component[file] { entered[component[target]] = true; } } } let names = |node: usize, target: usize| { let group = component[target / 2]; component[node / 2] != group || entered[group] || (has_root[group] && !root_file(target / 2)) }; // The nodes that are loaded: a file that no loaded node names is a crate root, loaded plainly, and a // node is loaded when a loaded node names it. Every file starts out loaded plainly, and the set is // narrowed until it stops changing, or after `MAX_MODULE_ROUNDS` rounds. let mut loaded: Vec = (0..paths.len() * 2).map(|node| node % 2 == 0).collect(); let mut named = vec![false; paths.len()]; for _ in 0..MAX_MODULE_ROUNDS { let mut reached = vec![false; paths.len() * 2]; for (node, targets) in edges.iter().enumerate() { if loaded[node] { for &(_, target) in targets { if names(node, target) { reached[target] = true; } } } } named = (0..paths.len()).map(|j| reached[2 * j] || reached[2 * j + 1]).collect(); let next: Vec = (0..paths.len() * 2).map(|node| reached[node] || (node % 2 == 0 && !named[node / 2])).collect(); if next == loaded { break; } loaded = next; } // Files the web build compiles: crate roots, and every file a declaration outside a native-only item // of such a file names. let mut web = vec![false; paths.len() * 2]; let mut queue: Vec = (0..paths.len()).filter(|&j| !named[j]).map(|j| 2 * j).collect(); for &node in &queue { web[node] = true; } while let Some(parent) = queue.pop() { for &(_, target) in edges[parent].iter().filter(|(is_native, _)| !is_native) { if !web[target] { web[target] = true; queue.push(target); } } } // Files a native-only declaration of a loaded node names, and their descendants. let mut native = vec![false; paths.len() * 2]; let starts = edges.iter().enumerate().filter(|&(node, _)| loaded[node]).flat_map(|(_, targets)| targets.iter()); for &(_, target) in starts.filter(|(is_native, _)| *is_native) { if !native[target] { native[target] = true; queue.push(target); } } while let Some(parent) = queue.pop() { for &(_, target) in &edges[parent] { if !native[target] { native[target] = true; queue.push(target); } } } (0..paths.len()).map(|j| (native[2 * j] || native[2 * j + 1]) && !web[2 * j] && !web[2 * j + 1]).collect() } /// The most rounds [`native_only_files`] spends narrowing the set of loaded files. const MAX_MODULE_ROUNDS: usize = 16; /// For each node of the graph `edges`, the number of its strongly connected component (Tarjan's /// algorithm, with an explicit stack in place of recursion). fn components(edges: &[Vec]) -> Vec { const UNSEEN: usize = usize::MAX; let mut index = vec![UNSEEN; edges.len()]; let mut low = vec![0; edges.len()]; let mut on_stack = vec![false; edges.len()]; let mut component = vec![UNSEEN; edges.len()]; let mut stack = Vec::new(); let mut next = 0; let mut count = 0; for root in 0..edges.len() { if index[root] != UNSEEN { continue; } index[root] = next; low[root] = next; next += 1; stack.push(root); on_stack[root] = true; // Each frame is a node and the position of the next edge of it to follow. let mut work = vec![(root, 0usize)]; while let Some(frame) = work.last_mut() { let node = frame.0; if let Some(&target) = edges[node].get(frame.1) { frame.1 += 1; if index[target] == UNSEEN { index[target] = next; low[target] = next; next += 1; stack.push(target); on_stack[target] = true; work.push((target, 0)); } else if on_stack[target] { low[node] = low[node].min(index[target]); } continue; } work.pop(); if let Some(&(parent, _)) = work.last() { low[parent] = low[parent].min(low[node]); } if low[node] == index[node] { while let Some(member) = stack.pop() { on_stack[member] = false; component[member] = count; if member == node { break; } } count += 1; } } } component } /// The innermost `{` around each token, and for each `}` the `{` it closes. fn brace_scopes(toks: &[Token]) -> (Vec>, Vec>) { let mut around = vec![None; toks.len()]; let mut opener = vec![None; toks.len()]; let mut open = Vec::new(); for (j, t) in toks.iter().enumerate() { around[j] = open.last().copied(); if t.is_punct('{') { open.push(j); } else if t.is_punct('}') { opener[j] = open.pop(); } } (around, opener) } /// Look a name up from `toks[at]` outward through the braces around it (`around`, from /// [`brace_scopes`]): the first value that `get` returns for a pair of braces, given the index of its /// `{`, or for the file, given `None`. The search ends with the body of the `mod` it starts in, since a /// module does not see the names its parent binds. `Some(None)` means no braces bind the name; `None` /// means the search passed [`MAX_NESTING`] levels. fn lookup(toks: &[Token], around: &[Option], at: usize, get: impl Fn(Option) -> Option) -> Option> { let mut scope = around.get(at).copied().flatten(); for _ in 0..=MAX_NESTING { if let Some(value) = get(scope) { return Some(Some(value)); } match scope { Some(o) if o >= 2 && toks[o - 2].is_ident("mod") && matches!(toks[o - 1].kind, Kind::Ident(_)) => return Some(None), Some(o) => scope = around[o], None => return Some(None), } } None } /// Add one finding for each line in `lines`, in line order, with the trimmed text of that line. fn report(findings: &mut Vec, path: &str, content: &str, lines: &BTreeSet) { if lines.is_empty() { return; } let text: Vec<&str> = content.lines().collect(); for &line in lines { let line_text = text.get(line.saturating_sub(1)).map_or("", |s| s.trim()); findings.push(Finding::new(path, line, line_text)); } } /// For each pair of braces (`None` for the file) and a name: whether a binding in those braces binds the /// name to the muda crate, and whether one binds it to something else. type CrateBindings<'a> = BTreeMap<(&'a str, Option), (bool, bool)>; /// The names of the muda crate in a file, and where each is bound. The names are `muda` itself and each /// name that `use muda as m;`, `use muda::{self as m};` or `extern crate muda as m;` gives it. For each /// name and each pair of braces, the bindings record whether a `use` or an `extern crate` in them binds /// the name to the crate, and whether a `use`, an `extern crate` or a `mod` in them binds it to something /// else. A binding to something else inside an item with a `cfg` attribute, or through `crate::`, `self::` /// or `super::` (which may be a re-export of the crate), is left out. fn muda_crate_bindings<'a>( toks: &'a [Token], leaves: &'a [UseLeaf], around: &[Option], gated: &[bool], ) -> (BTreeSet<&'a str>, CrateBindings<'a>) { // Each `extern crate c;` or `extern crate c as n;`: whether `c` is muda, and the index of the name it // binds. let mut externs: Vec<(bool, &'a str, usize)> = Vec::new(); for i in 0..toks.len() { if toks[i].is_ident("extern") && toks.get(i + 1).is_some_and(|t| t.is_ident("crate")) && let Some(Kind::Ident(krate)) = toks.get(i + 2).map(|t| &t.kind) { let at = if toks.get(i + 3).is_some_and(|t| t.is_ident("as")) { i + 4 } else { i + 2 }; if let Some(Kind::Ident(name)) = toks.get(at).map(|t| &t.kind) && name != "_" { externs.push((krate == "muda", name.as_str(), at)); } } } let mut names: BTreeSet<&'a str> = BTreeSet::from(["muda"]); names.extend(leaves.iter().filter(|leaf| leaf.path == ["muda"]).filter_map(UseLeaf::binding)); names.extend(externs.iter().filter(|&&(muda, _, _)| muda).map(|&(_, name, _)| name)); let mut bound: CrateBindings<'a> = BTreeMap::new(); // `use muda as m;` binds `m` to the crate only where `muda` itself names the crate, so it is read // after every other binding. let renames = |leaf: &UseLeaf| leaf.path == ["muda"] && leaf.binding() != Some("muda"); for leaf in leaves.iter().filter(|leaf| !renames(leaf)) { let Some(name) = leaf.binding().filter(|name| names.contains(name)) else { continue }; let local = leaf.root.as_deref().is_some_and(|s| matches!(s, "crate" | "self" | "super")); let entry = bound.entry((name, around.get(leaf.start).copied().flatten())); if leaf.path == ["muda"] { entry.or_default().0 = true; } else if !local && !gated.get(leaf.start).copied().unwrap_or(false) { entry.or_default().1 = true; } } for &(muda, name, at) in &externs { if !names.contains(name) { continue; } if muda { bound.entry((name, around[at])).or_default().0 = true; } else if !gated[at] { bound.entry((name, around[at])).or_default().1 = true; } } for (i, t) in toks.iter().enumerate() { if let Kind::Ident(name) = &t.kind && names.contains(name.as_str()) && i.checked_sub(1).is_some_and(|k| toks[k].is_ident("mod")) && !gated[i] { bound.entry((name, around[i])).or_default().1 = true; } } let mut renamed = Vec::new(); for leaf in leaves.iter().filter(|leaf| renames(leaf)) { let Some(name) = leaf.binding() else { continue }; let crate_here = leaf.absolute || !matches!(lookup(toks, around, leaf.start, |scope| bound.get(&("muda", scope)).copied()), Some(Some((false, true)))); let local = leaf.root.as_deref().is_some_and(|s| matches!(s, "crate" | "self" | "super")); let scope = around.get(leaf.start).copied().flatten(); if crate_here { renamed.push((name, scope, true)); } else if !local && !gated.get(leaf.start).copied().unwrap_or(false) { renamed.push((name, scope, false)); } } for (name, scope, muda) in renamed { let entry = bound.entry((name, scope)).or_default(); if muda { entry.0 = true; } else { entry.1 = true; } } (names, bound) } /// Guard: detects direct calls to `muda`'s predefined Quit menu item. /// /// Using `PredefinedMenuItem::quit` connects the macOS menu directly to `NSApplication terminate:`, /// which bypasses dirty document checks, unsaved changes save prompts, and lifecycle cleanup. /// Applications should route Quit through custom menu items or interceptors connected to `craft-quit`. /// /// The guard reads Rust tokens, so comments, strings and character literals are ignored, and whitespace /// or line breaks around `::` do not hide a call. A qualified path such as `::quit` /// is reported too. A path that names the type through another crate or module, such as /// `other::PredefinedMenuItem::quit`, is not, and neither is a path through a name `muda` that the innermost /// braces binding it bind only to something else (`use other_menu as muda;`, `mod muda`), read like a name /// used on its own below; `::muda::PredefinedMenuItem` always names the crate. A name that the crate is /// imported under (`use muda as menu;`, `use muda::{self as menu};`, `extern crate muda as menu;`) is read /// like `muda` in the braces that bind it, so `menu::PredefinedMenuItem::quit` is reported there. It also /// follows a `use` or a `type` alias that renames muda's type (`use muda::PredefinedMenuItem as Item;` then /// `Item::quit`); a rename of another crate's `PredefinedMenuItem` is not followed, including one through a /// name `muda` that the braces around the `use` or `type` bind to something else, read as for a qualified /// path. /// /// A name used on its own (`PredefinedMenuItem::quit`, `Item::quit`) is read in the innermost braces /// around it, within its module, or the file, that bind the name. It is reported when those braces /// import or alias muda's type under it, and not when they only import another type under it /// (`use other::PredefinedMenuItem;`) or define one (`struct PredefinedMenuItem`). Where no braces bind /// it, `PredefinedMenuItem` is reported and a renamed name is not. An import or definition inside an /// item with a `cfg` attribute, an import or a type alias through `crate::`, `self::` or `super::` /// (which may be a re-export of muda's type), and an associated `type` in an `impl` or `trait` do not /// bind the name. Each finding names the line where the type's name starts, once per line, in line order. pub fn predefined_quit(files: I) -> Vec where I: IntoIterator, I::Item: AsFileSource, { let mut findings = Vec::new(); for file in files { let path = file.path(); let content = file.content(); let toks = lex_rust(content); let leaves = use_leaves(&toks, &BTreeSet::new()); let (around, opener) = brace_scopes(&toks); let gated = cfg_covered(&toks, true); let (crate_names, crate_bound) = muda_crate_bindings(&toks, &leaves, &around, &gated); let names_crate = |s: &str| crate_names.contains(s); // Whether `name`, read at token `i`, names the crate. After a leading `::` only `muda` does. // Otherwise `muda` does unless the innermost braces around `i` that bind `muda` bind it only to // something else, and another name of the crate does when those braces bind it to the crate, or // only to nothing else. let crate_name_at = |name: &str, i: usize, absolute: bool| { if absolute || !names_crate(name) { return name == "muda"; } match lookup(&toks, &around, i, |scope| crate_bound.get(&(name, scope)).copied()) { None => true, Some(Some((muda, other))) => muda || !other, Some(None) => name == "muda", } }; // Whether the identifier at `i` names the crate. let crate_is_muda = |i: usize| { let Kind::Ident(name) = &toks[i].kind else { return false }; let absolute = i >= 2 && toks[i - 1].is_punct(':') && toks[i - 2].is_punct(':'); crate_name_at(name, i, absolute) }; // A `use` path to muda's type, read through a name of the crate bound where the `use` is. After // a leading `::` the first segment is an external crate, so only `muda` names it. let is_muda = |leaf: &UseLeaf| leaf.path.len() == 2 && leaf.path[1] == "PredefinedMenuItem" && crate_name_at(&leaf.path[0], leaf.start, leaf.absolute); // Whether the braces opened at `o` are the body of an `impl` or a `trait`, whose `type` items are // associated types rather than names in scope. The head is read back from `o` to the `;`, `{` or // `}` before it, stepping over a block in angle brackets (`impl Foo<{ N }>`), for at most // `ATTRIBUTE_SCAN_LIMIT` tokens. let assoc_body = |o: usize| { let mut j = o; let mut depth = 0usize; let mut start = None; for _ in 0..ATTRIBUTE_SCAN_LIMIT { let Some(k) = j.checked_sub(1) else { start = Some(0); break; }; let t = &toks[k]; if depth == 0 && (t.is_punct(';') || t.is_punct('{')) { start = Some(k + 1); break; } if depth == 0 && t.is_punct('}') { let generic = opener[k].filter(|&b| b.checked_sub(1).is_some_and(|p| ['<', ',', '='].iter().any(|&c| toks[p].is_punct(c)))); if let Some(b) = generic { j = b; continue; } start = Some(k + 1); break; } match t.kind { Kind::Punct(')' | ']') => depth += 1, Kind::Punct('(' | '[') => depth = depth.saturating_sub(1), _ => {} } j = k; } let Some(mut s) = start else { return false }; // Attributes and modifiers before the keyword. while s < o { let next = |c: char| toks.get(s + 1).is_some_and(|t| t.is_punct(c)); if (toks[s].is_punct('#') && next('[')) || (toks[s].is_ident("pub") && next('(')) { // `#[...]` or `pub(...)`. s = matching_close(&toks, s + 1).saturating_add(1); } else if ["pub", "unsafe", "auto", "default"].iter().any(|m| toks[s].is_ident(m)) { s += 1; } else { break; } } s < o && (toks[s].is_ident("impl") || toks[s].is_ident("trait")) }; // Whether the `type` name at `i` is followed by `= muda::PredefinedMenuItem;` (or `::muda::...`, or // a name of the crate in place of `muda`). let aliases_muda = |i: usize| { let mut j = i + 1; if !toks.get(j).is_some_and(|t| t.is_punct('=')) { return false; } j += 1; if toks.get(j).is_some_and(|t| t.is_punct(':')) && toks.get(j + 1).is_some_and(|t| t.is_punct(':')) { j += 2; } j < toks.len() && crate_is_muda(j) && then_path(&toks, j + 1, |s| s == "PredefinedMenuItem") && toks.get(j + 4).is_some_and(|t| t.is_punct(';')) }; let definition = |i: usize| i.checked_sub(1).is_some_and(|k| ["struct", "enum", "union", "type", "trait"].iter().any(|kw| toks[k].is_ident(kw))); // The names of muda's type: its own, and each name a `use` or a `type` alias gives it. let mut names: BTreeSet<&str> = BTreeSet::from(["PredefinedMenuItem"]); names.extend(leaves.iter().filter(|leaf| is_muda(leaf)).filter_map(UseLeaf::binding)); for (i, t) in toks.iter().enumerate() { if let Kind::Ident(name) = &t.kind && i.checked_sub(1).is_some_and(|k| toks[k].is_ident("type")) && aliases_muda(i) { names.insert(name); } } // For each of those names and each pair of braces (`None` for the file), whether a `use` or a // type alias in it binds the name to muda's type, and whether a `use` or an item definition in it // binds the name to another type. A binding to another type inside an item with a `cfg` // attribute may not apply on the platform the guard protects, so it is left out. let mut bound: BTreeMap<(&str, Option), (bool, bool)> = BTreeMap::new(); for leaf in &leaves { let Some(name) = leaf.binding().filter(|name| names.contains(name)) else { continue }; let muda = is_muda(leaf); // A path into this crate (`crate::`, `self::`, `super::`) may lead to a re-export of muda's // type, so it is not counted as another type. let local = leaf.root.as_deref().is_some_and(|s| matches!(s, "crate" | "self" | "super")); if muda || (!local && !gated.get(leaf.start).copied().unwrap_or(false)) { let entry = bound.entry((name, around.get(leaf.start).copied().flatten())).or_default(); if muda { entry.0 = true; } else { entry.1 = true; } } } for (i, t) in toks.iter().enumerate() { let Kind::Ident(name) = &t.kind else { continue }; let Some(k) = i.checked_sub(1) else { continue }; if !names.contains(name.as_str()) || !definition(i) { continue; } if toks[k].is_ident("type") && around[i].is_some_and(assoc_body) { continue; } // An alias of a path into this crate may name a re-export of muda's type, as an import does. let local_alias = toks.get(i + 1).is_some_and(|t| t.is_punct('=')) && toks.get(i + 2).is_some_and(|t| t.is_ident("crate") || t.is_ident("self") || t.is_ident("super")); if toks[k].is_ident("type") && local_alias { continue; } let key = (name.as_str(), around[i]); if toks[k].is_ident("type") && aliases_muda(i) { bound.entry(key).or_default().0 = true; } else if !gated[i] { bound.entry(key).or_default().1 = true; } } // A name used on its own is muda's type when the innermost braces around it that bind it (within // its module) bind it to muda's type, or only to nothing else. Where no braces bind it, only // `PredefinedMenuItem` itself is muda's type. Past `MAX_NESTING` levels it is read as muda's type. let bare_is_muda = |name: &str, i: usize| match lookup(&toks, &around, i, |scope| bound.get(&(name, scope)).copied()) { None => true, Some(Some((muda, other))) => muda || !other, Some(None) => name == "PredefinedMenuItem", }; let mut lines = BTreeSet::new(); for (i, tok) in toks.iter().enumerate() { let Kind::Ident(name) = &tok.kind else { continue }; if !names.contains(name.as_str()) { continue; } // A qualified name counts only as `muda::PredefinedMenuItem` (or `::muda::...`, or a name of the // crate in place of `muda`), not as another crate's or module's type of the same name. let named = if continues_a_path(&toks, i) { name == "PredefinedMenuItem" && !continues_a_path(&toks, i - 3) && crate_is_muda(i - 3) } else { bare_is_muda(name, i) }; let quit = |at: usize| then_path(&toks, at, |s| s == "quit" || s == "Quit"); // `::quit`, a qualified path to the same function. let qualified = || toks.get(i + 1).is_some_and(|t| t.is_punct('>')) && quit(i + 2) && opens_qualified_path(&toks, i); if named && (quit(i + 1) || qualified()) { lines.insert(tok.line); } } report(&mut findings, path, content, &lines); } findings } /// Guard: detects uses of `std::time::Instant` in code paths running on the web. /// /// On `wasm32-unknown-unknown`, `std::time::Instant::now()` panics with "time not implemented /// on this platform". Crates running in the browser should use `web_time::Instant`, which maps to /// `std::time::Instant` on native platforms and `performance.now()` on the web. /// /// ### Syntactic Scope and Limitations /// /// * **Targeted files**: Callers should pass files from crates that compile into the application's web build. /// * **What is reported**: the paths `std::time::Instant` and `::std::time::Instant`; `::Instant` where a /// `use` outside a native-only item binds `m` to `std::time` (`use std::time;`, `use std::time as t;`, /// `use std::time::{self as t}`); /// and every `use` that imports `std::time::Instant` or `std::time::*`, under any name, directly or through /// such an `m` of any length (`use m::{Instant as Clock};`, `use m::*;`). Whitespace, comments /// and line breaks may separate the parts of a path. Each finding names the line where the path starts (in a /// `use` group, the line where the name's part of the group starts), once per line, in line order. /// * **What is skipped**: comments, string and character literals, other crates' `Instant` (`web_time::Instant`, /// a `time` module that is not `std::time`), and items whose `cfg` attribute is false on `wasm32-unknown-unknown` /// (for example `#[cfg(not(target_arch = "wasm32"))]`, `#[cfg(all(unix, ...))]`, `#[cfg(target_os = "macos")]`, /// or `#![cfg(...)]` for the rest of a module). Such an attribute covers only its item: code before the /// attribute or after the item on the same line is checked. A statement whose value holds a block, such as /// `let n = match x { ... } as u64 + ...;`, is covered up to its `;`. `cfg(false)` is false and `cfg(true)` /// is true. A predicate that depends on a feature or on `test`, or that is nested more than 64 levels deep, /// is not known from the source, so the item is checked. Escapes in a predicate's string values are decoded. /// * **Module files**: a `mod name;` inside such an item makes the module's file native-only, and so are the /// files of the modules declared in it, when they are among `files`, unless a chain of declarations outside /// such items also reaches the file from a crate root (a file that no declaration names, or in a cycle of /// declarations that no file outside the cycle names, such as `lib.rs` naming itself through `#[path]`, the /// cycle's `lib.rs` or `main.rs`, or every file of the cycle when it has neither). The module's file is `name.rs` or /// `name/mod.rs` next to `lib.rs`, `main.rs`, `mod.rs` or a file that a `#[path]` attribute names, and in /// the folder named after any other file's stem, below the folders of enclosing inline modules; a `#[path = "..."]` attribute on the declaration /// or on an enclosing inline module is followed. Paths are compared as text with `\` read as `/`, so the files must be named the same way /// (for example all from one `rust_sources` call), and a crate root other than `lib.rs` or `main.rs` /// (such as `src/bin/tool.rs`) is read as an ordinary module file. A declaration inside more than 64 inline /// modules is not followed, so its file is checked. /// * **Limitations**: This is a lexical source guard. It does not expand macros, resolve paths through other /// modules or re-exports, or rename `std` itself (`use std as s;`). An alias of `std::time` counts inside the /// braces of its `use` (or the file), down to but not into the body of a nested `mod`; nearer braces whose /// `use` or `mod` binds the same name to something else hide it, unless that `use` or `mod` carries a `cfg` /// attribute of its own that is not known to be true on `wasm32-unknown-unknown`, which may leave it out of /// the web build. pub fn std_instant(files: I) -> Vec where I: IntoIterator, I::Item: AsFileSource, { let files: Vec = files.into_iter().collect(); let paths: Vec = files.iter().map(|file| normalize_path(file.path())).collect(); // Only the declarations are kept from this pass, so the tokens of every file are never held at once. let decls: Vec> = files .iter() .map(|file| { let toks = lex_rust(file.content()); module_decls(&toks, &native_only(&toks)) }) .collect(); let excluded = native_only_files(&paths, &decls); let mut findings = Vec::new(); for (file, excluded) in files.iter().zip(excluded) { if excluded { continue; } let path = file.path(); let content = file.content(); let toks = lex_rust(content); let skip = native_only(&toks); let leaves = use_leaves(&toks, &BTreeSet::new()); let modules: BTreeSet = leaves .iter() .filter(|leaf| leaf.path == ["std", "time"] && !skip.get(leaf.start).copied().unwrap_or(false)) .filter_map(|leaf| leaf.binding().map(str::to_owned)) .collect(); // For each alias name and each pair of braces (`None` for the file), whether a `use` in it binds // the name to `std::time`, and whether a `use` or a `mod` binds the name to something else, unless // its own `cfg` attribute may be false on the web. let (around, _) = brace_scopes(&toks); let gated = cfg_items(&toks); let mut bound: BTreeMap<(&str, Option), (bool, bool)> = BTreeMap::new(); for leaf in &leaves { let Some(name) = leaf.binding().filter(|name| modules.contains(*name)) else { continue }; let time = leaf.path == ["std", "time"]; // A `use` of something else that carries a `cfg` attribute of its own that may be false on the // web may be absent from the web build, so it does not hide an outer alias. if !skip.get(leaf.start).copied().unwrap_or(false) && (time || !gated.contains(&leaf.start)) { let entry = bound.entry((name, around.get(leaf.start).copied().flatten())).or_default(); if time { entry.0 = true; } else { entry.1 = true; } } } for (i, t) in toks.iter().enumerate() { if let Kind::Ident(name) = &t.kind && modules.contains(name) && !skip[i] && i.checked_sub(1).is_some_and(|k| toks[k].is_ident("mod") && !gated.contains(&k)) { bound.entry((name.as_str(), around[i])).or_default().1 = true; } } // Whether `name` at `toks[at]` is an alias of `std::time`: the innermost braces around it that // bind the name (within its module) bind it to `std::time`. Past `MAX_NESTING` levels it is. let time_alias = |name: &str, at: usize| match lookup(&toks, &around, at, |scope| bound.get(&(name, scope)).copied()) { None => true, Some(Some((time, _))) => time, Some(None) => false, }; // Read again with the aliases of `std::time`, so a path through an alias starts with `std::time`. // The leaves read without aliases are checked as well, since an alias does not reach every `use` // whose path starts with its name (an alias in a nested module named `std`). let aliased = if modules.is_empty() { Vec::new() } else { use_leaves(&toks, &modules) }; let is_std_time = |path: &[String]| path == ["std", "time"]; let mut lines = BTreeSet::new(); for leaf in leaves.iter().chain(&aliased) { if skip.get(leaf.start).copied().unwrap_or(false) { continue; } let imports_instant = if leaf.name.is_none() { is_std_time(&leaf.path) } else { leaf.path.split_last().is_some_and(|(last, parent)| last == "Instant" && is_std_time(parent)) }; // A path read through an alias counts only where the alias names `std::time`. let through_other = leaf.alias.is_some_and(|a| matches!(&toks[a].kind, Kind::Ident(root) if !time_alias(root, leaf.start))); if imports_instant && !through_other { lines.insert(leaf.line); } } for (i, tok) in toks.iter().enumerate() { if skip[i] || continues_a_path(&toks, i) { continue; } let Kind::Ident(name) = &tok.kind else { continue }; let hit = if name == "std" { then_path(&toks, i + 1, |s| s == "time") && then_path(&toks, i + 4, |s| s == "Instant") } else { modules.contains(name) && then_path(&toks, i + 1, |s| s == "Instant") && time_alias(name, i) }; if hit { lines.insert(tok.line); } } report(&mut findings, path, content, &lines); } findings } /// Replace WGSL comments (`//` and nested `/* ... */`) with spaces, and write each WGSL line break as /// `\n`: line feed, vertical tab, form feed, carriage return, carriage return and line feed as one /// break, next line (U+0085), line separator (U+2028) and paragraph separator (U+2029) /// (). A line comment ends at any of them, and `str::lines` /// then counts lines the way WGSL does. fn mask_wgsl_comments(code: &str) -> String { let chars: Vec = code.chars().collect(); let len = chars.len(); let mut out = String::with_capacity(code.len()); let mut i = 0; let mut depth = 0usize; let mut in_line = false; while i < len { let c = chars[i]; let next = chars.get(i + 1).copied(); let line_break = match c { '\r' if next == Some('\n') => 2, '\n' | '\u{000B}' | '\u{000C}' | '\r' | '\u{0085}' | '\u{2028}' | '\u{2029}' => 1, _ => 0, }; if line_break > 0 { in_line = false; out.push('\n'); i += line_break; } else if in_line { out.push(' '); i += 1; } else if c == '/' && next == Some('*') { depth += 1; out.push_str(" "); i += 2; } else if depth > 0 && c == '*' && next == Some('/') { depth -= 1; out.push_str(" "); i += 2; } else if depth > 0 { out.push(' '); i += 1; } else if c == '/' && next == Some('/') { in_line = true; out.push_str(" "); i += 2; } else { out.push(c); i += 1; } } out } /// The largest finite value of the type a WGSL float literal with this suffix has. fn float_limit(suffix: Option) -> f64 { if suffix == Some(b'h') { 65504.0 } else { f64::from(f32::MAX) } } /// Read a WGSL hexadecimal literal starting at the `0` of `0x`. Returns the index after it, the length of /// its text without a suffix, and whether it is a float above the range of its type. fn scan_wgsl_hex(code: &[u8], start: usize) -> (usize, usize, bool) { // Significant hex digits kept; 15 hold 60 bits, more than an f64 mantissa. const KEPT: usize = 15; let mut i = start + 2; let mut mantissa = 0f64; let mut kept = 0usize; let mut exponent: i64 = 0; let mut digits = 0usize; let mut digit = |d: u8, fraction: bool, exponent: &mut i64| { let value = (d as char).to_digit(16).unwrap_or(0); if mantissa == 0.0 && value == 0 { if fraction { *exponent -= 4; } } else if kept < KEPT { mantissa = mantissa * 16.0 + f64::from(value); kept += 1; if fraction { *exponent -= 4; } } else if !fraction { *exponent += 4; } }; while i < code.len() && code[i].is_ascii_hexdigit() { digit(code[i], false, &mut exponent); digits += 1; i += 1; } let mut is_float = false; if code.get(i) == Some(&b'.') { is_float = true; i += 1; while i < code.len() && code[i].is_ascii_hexdigit() { digit(code[i], true, &mut exponent); digits += 1; i += 1; } } let mut has_exponent = false; if matches!(code.get(i), Some(b'p' | b'P')) { let mut j = i + 1; let negative = code.get(j) == Some(&b'-'); if matches!(code.get(j), Some(b'+' | b'-')) { j += 1; } if code.get(j).is_some_and(u8::is_ascii_digit) { let mut e: i64 = 0; while j < code.len() && code[j].is_ascii_digit() { e = (e * 10 + i64::from(code[j] - b'0')).min(1_000_000); j += 1; } exponent += if negative { -e } else { e }; has_exponent = true; is_float = true; i = j; } } let text_len = i - start; let suffix = if has_exponent && matches!(code.get(i), Some(b'f' | b'h')) { code.get(i).copied() } else { None }; let end = if suffix.is_some() || (!is_float && matches!(code.get(i), Some(b'i' | b'u'))) { i + 1 } else { i }; if !is_float || digits == 0 || mantissa == 0.0 { return (end, text_len, false); } let scale = i32::try_from(exponent.clamp(-4000, 4000)).unwrap_or(0); let value = mantissa * 2f64.powi(scale); (end, text_len, !value.is_finite() || value > float_limit(suffix)) } /// Guard: scans a single WGSL shader string and detects float literals outside their type's finite range. /// /// WebGPU compilers in browsers reject a float literal above `f32::MAX` (e.g. `3.40282347e38`) with a /// pipeline build error, which turns off GPU rendering. `f32::MAX` can be written as the hex float /// `0x1.fffffep+127f`, which equals it, or as the decimal `3.4028234663852886e38`, which rounds to it. /// /// ### Policy and Limitations /// /// * **Conservative mathematical bound**: The guard compares the literal's value, rounded to `f64`, /// with `f64::from(f32::MAX)`, or with 65504 (the largest finite `f16`) for an `h` suffix. Any literal /// above it is reported, even one that a compiler would round down to the maximum. A literal that exceeds /// the maximum by less than `f64` precision (such as `0x1.fffffe000000001p+127f`) rounds to the maximum and /// is not reported. /// * **Which literals**: decimal floats (with a `.`, an exponent or an `f`/`h` suffix) and hexadecimal floats /// (`0x` with a `.` or a `p` exponent). Integer literals (`123`, `123u`, `0xFFi`, `0x1f`) are not floats and /// are not reported. A `-` in front is not part of the literal, so `-1e39` is reported as `1e39`. /// * **Comments**: Comments (`//` and nested `/* ... */`) are masked out prior to scanning. A `//` comment /// ends at any WGSL line break, a lone carriage return included, and finding lines count every one of them. /// * **Identifiers**: digits inside an identifier, `π1e39` included, are not a literal. pub fn wgsl_float_literals(wgsl: &str) -> Vec { wgsl_float_literals_in([("", wgsl)]) } /// Guard: scans multiple WGSL shader files and detects float literals outside their type's finite range, /// with the rules of [`wgsl_float_literals`]. pub fn wgsl_float_literals_in(files: I) -> Vec where I: IntoIterator, I::Item: AsFileSource, { let mut findings = Vec::new(); for file in files { let path = file.path(); let masked = mask_wgsl_comments(file.content()); for (n, line) in masked.lines().enumerate() { let code = line.as_bytes(); let mut i = 0; while i < code.len() { let digit_or_dot = code[i].is_ascii_digit() || (code[i] == b'.' && code.get(i + 1).is_some_and(u8::is_ascii_digit)); // Outside comments, a character that is not ASCII and not blankspace (U+200E, U+200F) is part of an // identifier, as in `π1e39`. let word_before = digit_or_dot && i > 0 && (code[i - 1].is_ascii_alphanumeric() || code[i - 1] == b'_' || code[i - 1] == b'.' || (!code[i - 1].is_ascii() && !line[..i].ends_with(['\u{200E}', '\u{200F}']))); if !digit_or_dot || word_before { i += 1; continue; } let start = i; if code[i] == b'0' && matches!(code.get(i + 1), Some(b'x' | b'X')) { let (end, text_len, over) = scan_wgsl_hex(code, i); if over { findings.push(Finding::new(path, n + 1, String::from_utf8_lossy(&code[start..start + text_len]).into_owned())); } i = end.max(i + 1); continue; } let mut is_float = false; while i < code.len() && code[i].is_ascii_digit() { i += 1; } if code.get(i) == Some(&b'.') { is_float = true; i += 1; while i < code.len() && code[i].is_ascii_digit() { i += 1; } } if matches!(code.get(i), Some(b'e' | b'E')) { let mut j = i + 1; if matches!(code.get(j), Some(b'+' | b'-')) { j += 1; } if code.get(j).is_some_and(u8::is_ascii_digit) { is_float = true; i = j; while i < code.len() && code[i].is_ascii_digit() { i += 1; } } } let literal = String::from_utf8_lossy(&code[start..i]).into_owned(); let suffix = match code.get(i) { Some(&s @ (b'f' | b'h')) => { is_float = true; i += 1; Some(s) } Some(b'i' | b'u') if !is_float => { i += 1; None } _ => None, }; if !is_float { continue; } let is_overflow = match literal.parse::() { Ok(v) => !v.is_finite() || v.abs() > float_limit(suffix), Err(_) => true, }; if is_overflow { findings.push(Finding::new(path, n + 1, literal)); } } } } findings } /// Size limits for [`rust_sources_with_limits`]. An input over a limit is an error. #[cfg(not(target_arch = "wasm32"))] #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SourceLimits { /// The largest single file read, in bytes. Default 8 MiB. pub max_file_bytes: u64, /// The largest total of all files read, in bytes. Default 256 MiB. pub max_total_bytes: u64, /// The most files read. Default 50,000. pub max_files: usize, } #[cfg(not(target_arch = "wasm32"))] impl Default for SourceLimits { fn default() -> Self { Self { max_file_bytes: 8 << 20, max_total_bytes: 256 << 20, max_files: 50_000 } } } /// The first line of a `CACHEDIR.TAG` file, which marks a folder of generated files /// (). Cargo writes one in each target folder. #[cfg(not(target_arch = "wasm32"))] const CACHEDIR_SIGNATURE: &[u8] = b"Signature: 8a477f597d28d172789f06886806bc55"; /// Whether `dir` holds a `CACHEDIR.TAG` regular file that starts with [`CACHEDIR_SIGNATURE`]. A marker /// that is a symbolic link, a folder, a FIFO or another special file is not opened and does not count. #[cfg(not(target_arch = "wasm32"))] fn is_cache_dir(dir: &Path) -> bool { use std::io::Read; let marker = dir.join("CACHEDIR.TAG"); if !std::fs::symlink_metadata(&marker).is_ok_and(|m| m.file_type().is_file()) { return false; } let Ok(file) = std::fs::File::open(&marker) else { return false; }; let mut head = Vec::with_capacity(CACHEDIR_SIGNATURE.len()); file.take(CACHEDIR_SIGNATURE.len() as u64).read_to_end(&mut head).is_ok() && head == CACHEDIR_SIGNATURE } /// Recursively collect all Rust source files under `dir`, excluding test files and test directories, /// with the default [`SourceLimits`]. /// /// Excluded files: /// * `tests.rs` /// * `tests_*.rs` /// * `*_tests.rs` /// * `*_test.rs` /// * `test.rs` /// * Any file below `dir` within a directory named `tests`, `benches`, `examples` or `target`, or whose /// name starts with `.`, or that holds a `CACHEDIR.TAG` regular file starting with the signature line /// `Signature: 8a477f597d28d172789f06886806bc55` (a build output folder with another name). A /// `CACHEDIR.TAG` that is a symbolic link or a special file such as a FIFO is not read, and its folder /// is listed. /// * Symbolic links (and, on Windows, junctions) to files or folders, which are not followed. /// /// Results are sorted lexicographically by file path for deterministic behavior across platforms. #[cfg(not(target_arch = "wasm32"))] pub fn rust_sources(dir: impl AsRef) -> std::io::Result> { rust_sources_with_limits(dir, SourceLimits::default()) } /// [`rust_sources`] with explicit size limits. A file over `max_file_bytes` returns an error of kind /// [`std::io::ErrorKind::FileTooLarge`]; more than `max_files` files or `max_total_bytes` bytes in all /// returns an error of kind [`std::io::ErrorKind::QuotaExceeded`]. #[cfg(not(target_arch = "wasm32"))] pub fn rust_sources_with_limits(dir: impl AsRef, limits: SourceLimits) -> std::io::Result> { use std::io::{Error, ErrorKind, Read}; let root = dir.as_ref(); let mut files = Vec::new(); let mut total: u64 = 0; let mut dirs = vec![root.to_path_buf()]; while let Some(d) = dirs.pop() { for entry in std::fs::read_dir(&d)? { let entry = entry?; let p = entry.path(); let kind = entry.file_type()?; if kind.is_symlink() { continue; } let name = entry.file_name(); let name = name.to_string_lossy(); if kind.is_dir() { if name.starts_with('.') || name == "target" || name == "tests" || name == "benches" || name == "examples" || is_cache_dir(&p) { continue; } dirs.push(p); } else if kind.is_file() { if !name.ends_with(".rs") { continue; } if name == "tests.rs" || name.starts_with("tests_") || name.ends_with("_tests.rs") || name.ends_with("_test.rs") || name == "test.rs" { continue; } if files.len() >= limits.max_files { return Err(Error::new( ErrorKind::QuotaExceeded, format!("more than {} Rust source files under {}", limits.max_files, root.display()), )); } let over_file = || Error::new(ErrorKind::FileTooLarge, format!("{} is larger than {} bytes", p.display(), limits.max_file_bytes)); if entry.metadata()?.len() > limits.max_file_bytes { return Err(over_file()); } let mut content = String::new(); std::fs::File::open(&p)?.take(limits.max_file_bytes.saturating_add(1)).read_to_string(&mut content)?; let size = content.len() as u64; if size > limits.max_file_bytes { return Err(over_file()); } total = total.saturating_add(size); if total > limits.max_total_bytes { return Err(Error::new( ErrorKind::QuotaExceeded, format!("Rust sources under {} are larger than {} bytes in all", root.display(), limits.max_total_bytes), )); } files.push((p.display().to_string(), content)); } } } files.sort_by(|a, b| a.0.cmp(&b.0)); Ok(files) } #[cfg(test)] mod tests { use std::collections::BTreeSet; use super::{MAX_USE_PATH, MAX_USE_SEGMENT, lex_rust, use_leaves}; fn paths_and_names(source: &str) -> Vec<(Vec, Option)> { use_leaves(&lex_rust(source), &BTreeSet::new()).into_iter().map(|leaf| (leaf.path, leaf.name.map(|name| name.to_string()))).collect() } #[test] fn use_leaves_keep_no_path_longer_than_the_limit() { let source = format!("use {}{{x, y::z, *}};\nuse std::time::{{Instant, self as t}};\n", "a::".repeat(MAX_USE_PATH)); let some = |name: &str| Some(name.to_string()); let path = |segments: &[&str]| segments.iter().map(|s| s.to_string()).collect::>(); assert_eq!( paths_and_names(&source), vec![ (Vec::new(), some("x")), (Vec::new(), some("z")), (vec!["a".to_string(); MAX_USE_PATH], None), (path(&["std", "time", "Instant"]), some("Instant")), (path(&["std", "time"]), some("t")), ] ); } #[test] fn use_leaves_keep_no_segment_longer_than_the_limit() { let long = "n".repeat(MAX_USE_SEGMENT + 1); let fits = "n".repeat(MAX_USE_SEGMENT); let source = format!("use {long}::{{self, x, *}};\nuse a::{long};\nuse {fits}::{{self as b, *}};\n"); assert_eq!( paths_and_names(&source), vec![ (Vec::new(), Some(long.clone())), (Vec::new(), Some("x".to_string())), (Vec::new(), Some(long)), (vec![fits.clone()], Some("b".to_string())), (vec![fits], None), ] ); } }