nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-28 11:07:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Minor documentation cleanups

Browse Source
This commit is contained in:
Johannes Linke 2016-01-01 17:49:01 +01:00
parent b287739c0b
commit f89e400578
3 changed files with 10 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/escape.rs
View File

@ -16,9 +16,9 @@ pub struct EscapePass;
/// **What it does:** This lint checks for usage of `Box<T>` where an unboxed `T` would work fine. It is `Warn` by default. /// **What it does:** This lint checks for usage of `Box<T>` where an unboxed `T` would work fine. It is `Warn` by default.
/// ///
/// **Why is this bad?** This is an unnecessary allocation, and bad for performance /// **Why is this bad?** This is an unnecessary allocation, and bad for performance. It is only necessary to allocate if you wish to move the box into something.
/// ///
/// It is only necessary to allocate if you wish to move the box into something. /// **Known problems:** None
/// ///
/// **Example:** /// **Example:**
/// ///

8
src/mut_reference.rs
View File

@ -36,7 +36,7 @@ impl LateLintPass for UnnecessaryMutPassed {
match borrowed_table.node_types.get(&fn_expr.id) { match borrowed_table.node_types.get(&fn_expr.id) {
Some(function_type) => { Some(function_type) => {
if let ExprPath(_, ref path) = fn_expr.node { if let ExprPath(_, ref path) = fn_expr.node {
check_arguments(cx, &arguments, function_type, check_arguments(cx, &arguments, function_type,
&format!("{}", path)); &format!("{}", path));
} }
} }
@ -50,7 +50,7 @@ impl LateLintPass for UnnecessaryMutPassed {
ExprMethodCall(ref name, _, ref arguments) => { ExprMethodCall(ref name, _, ref arguments) => {
let method_call = MethodCall::expr(e.id); let method_call = MethodCall::expr(e.id);
match borrowed_table.method_map.get(&method_call) { match borrowed_table.method_map.get(&method_call) {
Some(method_type) => check_arguments(cx, &arguments, method_type.ty, Some(method_type) => check_arguments(cx, &arguments, method_type.ty,
&format!("{}", name.node.as_str())), &format!("{}", name.node.as_str())),
None => unreachable!(), // Just like above, this should never happen. None => unreachable!(), // Just like above, this should never happen.
}; };
@ -68,9 +68,9 @@ fn check_arguments(cx: &LateContext, arguments: &[P<Expr>], type_definition: &Ty
TypeVariants::TyRef(_, TypeAndMut {mutbl: MutImmutable, ..}) | TypeVariants::TyRef(_, TypeAndMut {mutbl: MutImmutable, ..}) |
TypeVariants::TyRawPtr(TypeAndMut {mutbl: MutImmutable, ..}) => { TypeVariants::TyRawPtr(TypeAndMut {mutbl: MutImmutable, ..}) => {
if let ExprAddrOf(MutMutable, _) = argument.node { if let ExprAddrOf(MutMutable, _) = argument.node {
span_lint(cx, UNNECESSARY_MUT_PASSED, span_lint(cx, UNNECESSARY_MUT_PASSED,
argument.span, &format!("The function/method \"{}\" \ argument.span, &format!("The function/method \"{}\" \
doesn't need a mutable reference", doesn't need a mutable reference",
name)); name));
} }
} }

8
src/precedence.rs
View File

@ -4,7 +4,7 @@ use syntax::ast::*;
use utils::{span_lint, snippet}; use utils::{span_lint, snippet};
/// **What it does:** This lint checks for operations where precedence may be unclear and `Warn`'s about them by default, suggesting to add parentheses. Currently it catches the following: /// **What it does:** This lint checks for operations where precedence may be unclear and `Warn`s about them by default, suggesting to add parentheses. Currently it catches the following:
/// * mixed usage of arithmetic and bit shifting/combining operators without parentheses /// * mixed usage of arithmetic and bit shifting/combining operators without parentheses
/// * a "negative" numeric literal (which is really a unary `-` followed by a numeric literal) followed by a method call /// * a "negative" numeric literal (which is really a unary `-` followed by a numeric literal) followed by a method call
/// ///
@ -33,17 +33,17 @@ impl EarlyLintPass for Precedence {
if let ExprBinary(Spanned { node: op, ..}, ref left, ref right) = expr.node { if let ExprBinary(Spanned { node: op, ..}, ref left, ref right) = expr.node {
if !is_bit_op(op) { return; } if !is_bit_op(op) { return; }
match (is_arith_expr(left), is_arith_expr(right)) { match (is_arith_expr(left), is_arith_expr(right)) {
(true, true) => span_lint(cx, PRECEDENCE, expr.span, (true, true) => span_lint(cx, PRECEDENCE, expr.span,
&format!("operator precedence can trip the unwary. \ &format!("operator precedence can trip the unwary. \
Consider parenthesizing your expression:\ Consider parenthesizing your expression:\
`({}) {} ({})`", snippet(cx, left.span, ".."), `({}) {} ({})`", snippet(cx, left.span, ".."),
op.to_string(), snippet(cx, right.span, ".."))), op.to_string(), snippet(cx, right.span, ".."))),
(true, false) => span_lint(cx, PRECEDENCE, expr.span, (true, false) => span_lint(cx, PRECEDENCE, expr.span,
&format!("operator precedence can trip the unwary. \ &format!("operator precedence can trip the unwary. \
Consider parenthesizing your expression:\ Consider parenthesizing your expression:\
`({}) {} {}`", snippet(cx, left.span, ".."), `({}) {} {}`", snippet(cx, left.span, ".."),
op.to_string(), snippet(cx, right.span, ".."))), op.to_string(), snippet(cx, right.span, ".."))),
(false, true) => span_lint(cx, PRECEDENCE, expr.span, (false, true) => span_lint(cx, PRECEDENCE, expr.span,
&format!("operator precedence can trip the unwary. \ &format!("operator precedence can trip the unwary. \
Consider parenthesizing your expression:\ Consider parenthesizing your expression:\
`{} {} ({})`", snippet(cx, left.span, ".."), `{} {} ({})`", snippet(cx, left.span, ".."),