115 lines
4.3 KiB
Rust
115 lines
4.3 KiB
Rust
use crate::{
|
||
lints::{
|
||
HiddenUnicodeCodepointsDiag, HiddenUnicodeCodepointsDiagLabels,
|
||
HiddenUnicodeCodepointsDiagSub,
|
||
},
|
||
EarlyContext, EarlyLintPass, LintContext,
|
||
};
|
||
use ast::util::unicode::{contains_text_flow_control_chars, TEXT_FLOW_CONTROL_CHARS};
|
||
use rustc_ast as ast;
|
||
use rustc_span::{BytePos, Span, Symbol};
|
||
|
||
declare_lint! {
|
||
/// The `text_direction_codepoint_in_literal` lint detects Unicode codepoints that change the
|
||
/// visual representation of text on screen in a way that does not correspond to their on
|
||
/// memory representation.
|
||
///
|
||
/// ### Explanation
|
||
///
|
||
/// The unicode characters `\u{202A}`, `\u{202B}`, `\u{202D}`, `\u{202E}`, `\u{2066}`,
|
||
/// `\u{2067}`, `\u{2068}`, `\u{202C}` and `\u{2069}` make the flow of text on screen change
|
||
/// its direction on software that supports these codepoints. This makes the text "abc" display
|
||
/// as "cba" on screen. By leveraging software that supports these, people can write specially
|
||
/// crafted literals that make the surrounding code seem like it's performing one action, when
|
||
/// in reality it is performing another. Because of this, we proactively lint against their
|
||
/// presence to avoid surprises.
|
||
///
|
||
/// ### Example
|
||
///
|
||
/// ```rust,compile_fail
|
||
/// #![deny(text_direction_codepoint_in_literal)]
|
||
/// fn main() {
|
||
/// println!("{:?}", '');
|
||
/// }
|
||
/// ```
|
||
///
|
||
/// {{produces}}
|
||
///
|
||
pub TEXT_DIRECTION_CODEPOINT_IN_LITERAL,
|
||
Deny,
|
||
"detect special Unicode codepoints that affect the visual representation of text on screen, \
|
||
changing the direction in which text flows",
|
||
}
|
||
|
||
declare_lint_pass!(HiddenUnicodeCodepoints => [TEXT_DIRECTION_CODEPOINT_IN_LITERAL]);
|
||
|
||
impl HiddenUnicodeCodepoints {
|
||
fn lint_text_direction_codepoint(
|
||
&self,
|
||
cx: &EarlyContext<'_>,
|
||
text: Symbol,
|
||
span: Span,
|
||
padding: u32,
|
||
point_at_inner_spans: bool,
|
||
label: &str,
|
||
) {
|
||
// Obtain the `Span`s for each of the forbidden chars.
|
||
let spans: Vec<_> = text
|
||
.as_str()
|
||
.char_indices()
|
||
.filter_map(|(i, c)| {
|
||
TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| {
|
||
let lo = span.lo() + BytePos(i as u32 + padding);
|
||
(c, span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
|
||
})
|
||
})
|
||
.collect();
|
||
|
||
let count = spans.len();
|
||
let labels = point_at_inner_spans
|
||
.then_some(HiddenUnicodeCodepointsDiagLabels { spans: spans.clone() });
|
||
let sub = if point_at_inner_spans && !spans.is_empty() {
|
||
HiddenUnicodeCodepointsDiagSub::Escape { spans }
|
||
} else {
|
||
HiddenUnicodeCodepointsDiagSub::NoEscape { spans }
|
||
};
|
||
|
||
cx.emit_span_lint(
|
||
TEXT_DIRECTION_CODEPOINT_IN_LITERAL,
|
||
span,
|
||
HiddenUnicodeCodepointsDiag { label, count, span_label: span, labels, sub },
|
||
);
|
||
}
|
||
}
|
||
impl EarlyLintPass for HiddenUnicodeCodepoints {
|
||
fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
|
||
if let ast::AttrKind::DocComment(_, comment) = attr.kind {
|
||
if contains_text_flow_control_chars(comment.as_str()) {
|
||
self.lint_text_direction_codepoint(cx, comment, attr.span, 0, false, "doc comment");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
|
||
// byte strings are already handled well enough by `EscapeError::NonAsciiCharInByteString`
|
||
match &expr.kind {
|
||
ast::ExprKind::Lit(token_lit) => {
|
||
let text = token_lit.symbol;
|
||
if !contains_text_flow_control_chars(text.as_str()) {
|
||
return;
|
||
}
|
||
let padding = match token_lit.kind {
|
||
// account for `"` or `'`
|
||
ast::token::LitKind::Str | ast::token::LitKind::Char => 1,
|
||
// account for `r###"`
|
||
ast::token::LitKind::StrRaw(n) => n as u32 + 2,
|
||
_ => return,
|
||
};
|
||
self.lint_text_direction_codepoint(cx, text, expr.span, padding, true, "literal");
|
||
}
|
||
_ => {}
|
||
};
|
||
}
|
||
}
|