"serde_derive 1.0.70 (registry+https://github.com/rust-lang/crates.io-index)",
]
+[[package]]
+name = "rls-data"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
[[package]]
name = "rls-rustc"
version = "0.5.0"
version = "0.0.0"
dependencies = [
"log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-data 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-data 0.18.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc 0.0.0",
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
"checksum rls-analysis 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "96f84d303dcbe1c1bdd41b10867d3399c38fbdac32c4e3645cdb6dbd7f82db1d"
"checksum rls-blacklist 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e4a9cc2545ccb7e05b355bfe047b8039a6ec12270d5f3c996b766b340a50f7d2"
"checksum rls-data 0.16.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3dd20763e1c60ae8945384c8a8fa4ac44f8afa7b0a817511f5e8927e5d24f988"
+"checksum rls-data 0.18.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f81e838ecff6830ed33c2907fd236f38d441c206e983a2aa29fbce99295fab9"
"checksum rls-rustc 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9dba7390427aefa953608429701e3665192ca810ba8ae09301e001b7c7bed0"
"checksum rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d7c7046dc6a92f2ae02ed302746db4382e75131b9ce20ce967259f6b5867a6a"
"checksum rls-vfs 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ecbc8541b4c341d6271eae10f869dd9d36db871afe184f5b6f9bffbd6ed0373f"
/// }
/// }
/// ```
+ ///
+ /// # Null-unchecked version
+ ///
+ /// If you are sure the pointer can never be null and are looking for some kind of
+ /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>, know that you can
+ /// dereference the pointer directly.
+ ///
+ /// ```
+ /// let ptr: *const u8 = &10u8 as *const u8;
+ ///
+ /// unsafe {
+ /// let val_back = &*ptr;
+ /// println!("We got back the value: {}!", val_back);
+ /// }
+ /// ```
#[stable(feature = "ptr_as_ref", since = "1.9.0")]
#[inline]
pub unsafe fn as_ref<'a>(self) -> Option<&'a T> {
/// }
/// }
/// ```
+ ///
+ /// # Null-unchecked version
+ ///
+ /// If you are sure the pointer can never be null and are looking for some kind of
+ /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>, know that you can
+ /// dereference the pointer directly.
+ ///
+ /// ```
+ /// let ptr: *mut u8 = &mut 10u8 as *mut u8;
+ ///
+ /// unsafe {
+ /// let val_back = &*ptr;
+ /// println!("We got back the value: {}!", val_back);
+ /// }
+ /// ```
#[stable(feature = "ptr_as_ref", since = "1.9.0")]
#[inline]
pub unsafe fn as_ref<'a>(self) -> Option<&'a T> {
use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin};
use syntax::ast;
use syntax_pos;
-use errors::DiagnosticBuilder;
+use errors::{DiagnosticBuilder, Applicability};
use borrowck::gather_loans::gather_moves::PatternSource;
pub struct MoveErrorCollector<'tcx> {
let initializer =
e.init.as_ref().expect("should have an initializer to get an error");
if let Ok(snippet) = bccx.tcx.sess.source_map().span_to_snippet(initializer.span) {
- err.span_suggestion(initializer.span,
- "consider using a reference instead",
- format!("&{}", snippet));
+ err.span_suggestion_with_applicability(
+ initializer.span,
+ "consider using a reference instead",
+ format!("&{}", snippet),
+ Applicability::MaybeIncorrect // using a reference may not be the right fix
+ );
}
}
_ => {
use rustc::lint::builtin::UNUSED_MUT;
use rustc::ty;
use rustc::util::nodemap::{FxHashMap, FxHashSet};
+use errors::Applicability;
use std::slice;
use syntax::ptr::P;
hir_id,
span,
"variable does not need to be mutable")
- .span_suggestion_short(mut_span, "remove this `mut`", "".to_owned())
+ .span_suggestion_short_with_applicability(
+ mut_span,
+ "remove this `mut`",
+ "".to_owned(),
+ Applicability::MachineApplicable)
.emit();
}
}
use rustc::ty::query::Providers;
use rustc::ty::{self, ParamEnv, TyCtxt, Ty};
-use rustc_errors::{Diagnostic, DiagnosticBuilder, Level};
+use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, Level};
use rustc_data_structures::graph::dominators::Dominators;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::indexed_set::IdxSetBuf;
span,
"variable does not need to be mutable",
);
- err.span_suggestion_short(mut_span, "remove this `mut`", "".to_owned());
+ err.span_suggestion_short_with_applicability(
+ mut_span,
+ "remove this `mut`",
+ "".to_owned(),
+ Applicability::MachineApplicable);
err.buffer(&mut mbcx.errors_buffer);
}
use syntax::visit::{self, Visitor};
use syntax_pos::Span;
use errors;
+use errors::Applicability;
struct AstValidator<'a> {
session: &'a Session,
);
match val.node {
ExprKind::Lit(ref v) if v.node.is_numeric() => {
- err.span_suggestion(
+ err.span_suggestion_with_applicability(
place.span.between(val.span),
"if you meant to write a comparison against a negative value, add a \
space in between `<` and `-`",
"< -".to_string(),
+ Applicability::MaybeIncorrect
);
}
_ => {}
use syntax::tokenstream::{TokenStream, TokenTree, Delimited};
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::{Span, DUMMY_SP};
+use errors::Applicability;
use std::cell::Cell;
use std::mem;
if let Some(suggestion) = suggestion {
if suggestion != name {
if let MacroKind::Bang = kind {
- err.span_suggestion(span, "you could try the macro", suggestion.to_string());
+ err.span_suggestion_with_applicability(
+ span,
+ "you could try the macro",
+ suggestion.to_string(),
+ Applicability::MaybeIncorrect
+ );
} else {
- err.span_suggestion(span, "try", suggestion.to_string());
+ err.span_suggestion_with_applicability(
+ span,
+ "try",
+ suggestion.to_string(),
+ Applicability::MaybeIncorrect
+ );
}
} else {
err.help("have you added the `#[macro_use]` on the module/import?");
if let Some(span) = span {
let found_use = if found_use { "" } else { "\n" };
self.session.struct_span_err(err.use_span, err.warn_msg)
- .span_suggestion(
+ .span_suggestion_with_applicability(
span,
"instead, import the procedural macro like any other item",
format!("use {}::{};{}", err.crate_name, err.name, found_use),
+ Applicability::MachineApplicable
).emit();
} else {
self.session.struct_span_err(err.use_span, err.warn_msg)
rustc_typeck = { path = "../librustc_typeck" }
syntax = { path = "../libsyntax" }
syntax_pos = { path = "../libsyntax_pos" }
-rls-data = "0.16"
+rls-data = "0.18"
rls-span = "0.4"
# FIXME(#40527) should move rustc serialize out of tree
rustc-serialize = "0.3"
use rustc_target::spec::abi;
use syntax::ast::Ident;
use syntax_pos::Span;
+use errors::Applicability;
use rustc::hir;
err.span_label(call_expr.span, "not a function");
if let Some(ref path) = unit_variant {
- err.span_suggestion(call_expr.span,
- &format!("`{}` is a unit variant, you need to write it \
- without the parenthesis", path),
- path.to_string());
+ err.span_suggestion_with_applicability(
+ call_expr.span,
+ &format!("`{}` is a unit variant, you need to write it \
+ without the parenthesis", path),
+ path.to_string(),
+ Applicability::MachineApplicable
+ );
}
if let hir::ExprKind::Call(ref expr, _) = call_expr.node {
use rustc::hir::{Item, ItemKind, print};
use rustc::ty::{self, Ty, AssociatedItem};
use rustc::ty::adjustment::AllowTwoPhase;
-use errors::{DiagnosticBuilder, SourceMapper};
+use errors::{Applicability, DiagnosticBuilder, SourceMapper};
use super::method::probe;
match (found.bit_width(), exp.bit_width()) {
(Some(found), Some(exp)) if found > exp => {
if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_truncate),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_truncate),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
}
(None, _) | (_, None) => {
if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, which {}",
- msg,
- depending_on_isize),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, depending_on_isize),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
}
_ => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_sign_extend),
- into_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_sign_extend),
+ into_suggestion,
+ Applicability::MachineApplicable
+ );
}
}
true
match (found.bit_width(), exp.bit_width()) {
(Some(found), Some(exp)) if found > exp => {
if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_truncate),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_truncate),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
}
(None, _) | (_, None) => {
if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, which {}",
- msg,
- depending_on_usize),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, depending_on_usize),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
}
_ => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_zero_extend),
- into_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_zero_extend),
+ into_suggestion,
+ Applicability::MachineApplicable
+ );
}
}
true
if can_cast {
match (found.bit_width(), exp.bit_width()) {
(Some(found), Some(exp)) if found > exp - 1 => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_truncate),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_truncate),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
(None, None) => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_truncate),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_truncate),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
(None, _) => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}",
- msg,
- depending_on_isize),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, depending_on_isize),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
(_, None) => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}",
- msg,
- depending_on_usize),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, depending_on_usize),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
_ => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_zero_extend),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_zero_extend),
+ cast_suggestion,
+ Applicability::MachineApplicable
+ );
}
}
}
if can_cast {
match (found.bit_width(), exp.bit_width()) {
(Some(found), Some(exp)) if found - 1 > exp => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_truncate),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_truncate),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
(None, None) => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_sign_extend),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_sign_extend),
+ cast_suggestion,
+ Applicability::MachineApplicable // lossy conversion
+ );
}
(None, _) => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}",
- msg,
- depending_on_usize),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, depending_on_usize),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
(_, None) => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}",
- msg,
- depending_on_isize),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, depending_on_isize),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
_ => {
- err.span_suggestion(expr.span,
- &format!("{}, which {}", msg, will_sign_extend),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, which {}", msg, will_sign_extend),
+ cast_suggestion,
+ Applicability::MachineApplicable
+ );
}
}
}
}
(&ty::Float(ref exp), &ty::Float(ref found)) => {
if found.bit_width() < exp.bit_width() {
- err.span_suggestion(expr.span,
- &format!("{} in a lossless way",
- msg),
- into_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{} in a lossless way", msg),
+ into_suggestion,
+ Applicability::MachineApplicable
+ );
} else if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, producing the closest possible value",
- msg),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, producing the closest possible value", msg),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
true
}
(&ty::Uint(_), &ty::Float(_)) | (&ty::Int(_), &ty::Float(_)) => {
if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, rounding the float towards zero",
- msg),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, rounding the float towards zero", msg),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
err.warn("casting here will cause undefined behavior if the rounded value \
cannot be represented by the target integer type, including \
`Inf` and `NaN` (this is a bug and will be fixed)");
(&ty::Float(ref exp), &ty::Uint(ref found)) => {
// if `found` is `None` (meaning found is `usize`), don't suggest `.into()`
if exp.bit_width() > found.bit_width().unwrap_or(256) {
- err.span_suggestion(expr.span,
- &format!("{}, producing the floating point \
- representation of the integer",
- msg),
- into_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, producing the floating point representation of the \
+ integer",
+ msg),
+ into_suggestion,
+ Applicability::MachineApplicable
+ );
} else if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, producing the floating point \
- representation of the integer, rounded if \
- necessary",
- msg),
- cast_suggestion);
+ err.span_suggestion_with_applicability(expr.span,
+ &format!("{}, producing the floating point representation of the \
+ integer, rounded if necessary",
+ msg),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
true
}
(&ty::Float(ref exp), &ty::Int(ref found)) => {
// if `found` is `None` (meaning found is `isize`), don't suggest `.into()`
if exp.bit_width() > found.bit_width().unwrap_or(256) {
- err.span_suggestion(expr.span,
- &format!("{}, producing the floating point \
- representation of the integer",
- msg),
- into_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, producing the floating point representation of the \
+ integer",
+ msg),
+ into_suggestion,
+ Applicability::MachineApplicable
+ );
} else if can_cast {
- err.span_suggestion(expr.span,
- &format!("{}, producing the floating point \
- representation of the integer, rounded if \
- necessary",
- msg),
- cast_suggestion);
+ err.span_suggestion_with_applicability(
+ expr.span,
+ &format!("{}, producing the floating point representation of the \
+ integer, rounded if necessary",
+ msg),
+ cast_suggestion,
+ Applicability::MaybeIncorrect // lossy conversion
+ );
}
true
}
use syntax::ast;
use syntax::util::lev_distance::find_best_match_for_name;
-use errors::DiagnosticBuilder;
+use errors::{Applicability, DiagnosticBuilder};
use syntax_pos::{Span, FileName};
}
if static_sources.len() == 1 {
if let Some(expr) = rcvr_expr {
- err.span_suggestion(expr.span.to(span),
+ err.span_suggestion_with_applicability(expr.span.to(span),
"use associated function syntax instead",
format!("{}::{}",
self.ty_to_string(actual),
- item_name));
+ item_name),
+ Applicability::MachineApplicable);
} else {
err.help(&format!("try with `{}::{}`",
self.ty_to_string(actual), item_name));
use rustc::ty::fold::TypeFoldable;
use rustc::ty::query::Providers;
use rustc::ty::util::{Representability, IntTypeExt, Discr};
-use errors::{DiagnosticBuilder, DiagnosticId};
+use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
use require_c_abi_if_variadic;
use session::{CompileIncomplete, config, Session};
let sugg_span = tcx.sess.source_map().end_point(expr_sp);
// remove closing `)` from the span
let sugg_span = sugg_span.shrink_to_lo();
- err.span_suggestion(
+ err.span_suggestion_with_applicability(
sugg_span,
"expected the unit value `()`; create it with empty parentheses",
- String::from("()"));
+ String::from("()"),
+ Applicability::MachineApplicable);
} else {
err.span_label(sp, format!("expected {}{} parameter{}",
if variadic {"at least "} else {""},
self.tcx.sess.source_map().span_to_snippet(lhs.span),
self.tcx.sess.source_map().span_to_snippet(rhs.span))
{
- err.span_suggestion(expr.span, msg, format!("{} == {}", left, right));
+ err.span_suggestion_with_applicability(
+ expr.span,
+ msg,
+ format!("{} == {}", left, right),
+ Applicability::MaybeIncorrect);
} else {
err.help(msg);
}
ast::LitIntType::Unsuffixed) = lit.node {
let snip = tcx.sess.source_map().span_to_snippet(base.span);
if let Ok(snip) = snip {
- err.span_suggestion(expr.span,
- "to access tuple elements, use",
- format!("{}.{}", snip, i));
+ err.span_suggestion_with_applicability(
+ expr.span,
+ "to access tuple elements, use",
+ format!("{}.{}", snip, i),
+ Applicability::MachineApplicable);
needs_note = false;
}
}
hir::ExprKind::Match(..) |
hir::ExprKind::Block(..) => {
let sp = self.tcx.sess.source_map().next_point(cause_span);
- err.span_suggestion(sp,
- "try adding a semicolon",
- ";".to_string());
+ err.span_suggestion_with_applicability(
+ sp,
+ "try adding a semicolon",
+ ";".to_string(),
+ Applicability::MachineApplicable);
}
_ => (),
}
// haven't set a return type at all (and aren't `fn main()` or an impl).
match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_nil()) {
(&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
- err.span_suggestion(span,
- "try adding a return type",
- format!("-> {} ",
- self.resolve_type_vars_with_obligations(found)));
+ err.span_suggestion_with_applicability(
+ span,
+ "try adding a return type",
+ format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
+ Applicability::MachineApplicable);
}
(&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
err.span_label(span, "possibly return type missing here?");
}
let original_span = original_sp(last_stmt.span, blk.span);
let span_semi = original_span.with_lo(original_span.hi() - BytePos(1));
- err.span_suggestion(span_semi, "consider removing this semicolon", "".to_string());
+ err.span_suggestion_with_applicability(
+ span_semi,
+ "consider removing this semicolon",
+ "".to_string(),
+ Applicability::MachineApplicable);
}
fn def_ids_for_path_segments(&self,
use lint;
use rustc::ty::TyCtxt;
+use errors::Applicability;
use syntax::ast;
use syntax_pos::Span;
let id = tcx.hir.hir_to_node_id(hir_id);
let msg = "unused extern crate";
tcx.struct_span_lint_node(lint, id, span, msg)
- .span_suggestion_short(span, "remove it", "".to_string())
+ .span_suggestion_short_with_applicability(
+ span,
+ "remove it",
+ "".to_string(),
+ Applicability::MachineApplicable)
.emit();
continue;
}
impl Clean<Type> for hir::Ty {
fn clean(&self, cx: &DocContext) -> Type {
use rustc::hir::*;
+
match self.node {
TyKind::Never => Never,
TyKind::Ptr(ref m) => RawPointer(m.mutbl.clean(cx), box m.ty.clean(cx)),
if let Some(bounds) = cx.impl_trait_bounds.borrow_mut().remove(&did) {
return ImplTrait(bounds);
}
+ } else if let Def::Existential(did) = path.def {
+ // This block is for returned impl trait only.
+ if let Some(node_id) = cx.tcx.hir.as_local_node_id(did) {
+ let item = cx.tcx.hir.expect_item(node_id);
+ if let hir::ItemKind::Existential(ref ty) = item.node {
+ return ImplTrait(ty.bounds.clean(cx));
+ }
+ }
}
let mut alias = None;
// http://www.unicode.org/Public/security/10.0.0/confusables.txt
use syntax_pos::{Span, NO_EXPANSION};
-use errors::DiagnosticBuilder;
+use errors::{Applicability, DiagnosticBuilder};
use super::StringReader;
const UNICODE_ARRAY: &[(char, &str, char)] = &[
let msg =
format!("Unicode character '{}' ({}) looks like '{}' ({}), but it is not",
ch, u_name, ascii_char, ascii_name);
- err.span_suggestion(span, &msg, ascii_char.to_string());
+ err.span_suggestion_with_applicability(
+ span,
+ &msg,
+ ascii_char.to_string(),
+ Applicability::MaybeIncorrect);
true
},
None => {
self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f)
}
- fn parse_seq_to_before_tokens<T, F>(&mut self,
- kets: &[&token::Token],
- sep: SeqSep,
- expect: TokenExpectType,
- mut f: F)
- -> PResult<'a, Vec<T>>
+ fn parse_seq_to_before_tokens<T, F>(
+ &mut self,
+ kets: &[&token::Token],
+ sep: SeqSep,
+ expect: TokenExpectType,
+ mut f: F,
+ ) -> PResult<'a, Vec<T>>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
{
let mut first: bool = true;
TokenExpectType::Expect,
|p| p.parse_ty())?;
self.bump(); // `)`
+ let span = lo.to(self.prev_span);
let output = if self.eat(&token::RArrow) {
Some(self.parse_ty_common(false, false)?)
} else {
None
};
- let span = lo.to(self.prev_span);
ParenthesisedArgs { inputs, output, span }.into()
};
}
/// Parse one of the items allowed by the flags.
- /// NB: this function no longer parses the items inside an
- /// extern crate.
fn parse_item_implementation(
&mut self,
attrs: Vec<Attribute>,
use syntax::symbol::Symbol;
use syntax::tokenstream;
use syntax_pos::{MultiSpan, Span, DUMMY_SP};
+use errors::Applicability;
use std::borrow::Cow;
use std::collections::hash_map::Entry;
0 => "{}".to_string(),
_ => format!("{}{{}}", "{} ".repeat(args.len())),
};
- err.span_suggestion(
+ err.span_suggestion_with_applicability(
fmt_sp.shrink_to_lo(),
"you might be missing a string literal to format with",
format!("\"{}\", ", sugg_fmt),
+ Applicability::MaybeIncorrect,
);
err.emit();
return DummyResult::raw_expr(sp);
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+pub trait Foo {}
+pub trait Foo2 {}
+
+pub struct Bar;
+
+impl Foo for Bar {}
+impl Foo2 for Bar {}
+
+// @!has foo/fn.foo.html '//section[@id="main"]//pre' "x: &\'x impl Foo"
+// @!has foo/fn.foo.html '//section[@id="main"]//pre' "-> &\'x impl Foo {"
+pub fn foo<'x>(x: &'x impl Foo) -> &'x impl Foo {
+ x
+}
+
+// @!has foo/fn.foo2.html '//section[@id="main"]//pre' "x: &\'x impl Foo"
+// @!has foo/fn.foo2.html '//section[@id="main"]//pre' '-> impl Foo2 {'
+pub fn foo2<'x>(_x: &'x impl Foo) -> impl Foo2 {
+ Bar
+}
+
+// @!has foo/fn.foo_foo.html '//section[@id="main"]//pre' '-> impl Foo + Foo2 {'
+pub fn foo_foo() -> impl Foo + Foo2 {
+ Bar
+}
+
+// @!has foo/fn.foo2.html '//section[@id="main"]//pre' "x: &'x (impl Foo + Foo2)"
+pub fn foo_foo_foo<'x>(_x: &'x (impl Foo + Foo2)) {
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-pass
+
+// Bastion of the Turbofish
+// ------------------------
+// Beware travellers, lest you venture into waters callous and unforgiving,
+// where hope must be abandoned, ere it is cruelly torn from you. For here
+// stands the bastion of the Turbofish: an impenetrable fortress holding
+// unshaking against those who would dare suggest the supererogation of the
+// Turbofish.
+//
+// Once I was young and foolish and had the impudence to imagine that I could
+// shake free from the coils by which that creature had us tightly bound. I
+// dared to suggest that there was a better way: a brighter future, in which
+// Rustaceans both new and old could be rid of that vile beast. But alas! In
+// my foolhardiness my ignorance was unveiled and my dreams were dashed
+// unforgivingly against the rock of syntactic ambiguity.
+//
+// This humble program, small and insignificant though it might seem,
+// demonstrates that to which we had previously cast a blind eye: an ambiguity
+// in permitting generic arguments to be provided without the consent of the
+// Great Turbofish. Should you be so naïve as to try to revolt against its
+// mighty clutches, here shall its wrath be indomitably displayed. This
+// program must pass for all eternity, fundamentally at odds with an impetuous
+// rebellion against the Turbofish.
+//
+// My heart aches in sorrow, for I know I am defeated. Let this be a warning
+// to all those who come after. Here stands the bastion of the Turbofish.
+
+fn main() {
+ let (oh, woe, is, me) = ("the", "Turbofish", "remains", "undefeated");
+ let _: (bool, bool) = (oh<woe, is>(me));
+}
|
note: ...which requires normalizing `ParamEnvAnd { param_env: ParamEnv { caller_bounds: [], reveal: All }, value: [u8; _] }`...
note: ...which requires const-evaluating `Foo::bytes::{{constant}}`...
- --> $SRC_DIR/libcore/mem.rs:323:14
+ --> $SRC_DIR/libcore/mem.rs:LL:COL
|
LL | unsafe { intrinsics::size_of::<T>() }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: ...which again requires computing layout of `Foo`, completing the cycle
note: cycle used when const-evaluating `Foo::bytes::{{constant}}`
- --> $SRC_DIR/libcore/mem.rs:323:14
+ --> $SRC_DIR/libcore/mem.rs:LL:COL
|
LL | unsafe { intrinsics::size_of::<T>() }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
+++ /dev/null
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// ignore-tidy-linelength
-
-// Test that `#[rustc_*]` attributes are gated by `rustc_attrs` feature gate.
-
-#[rustc_variance] //~ ERROR the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable
-#[rustc_error] //~ ERROR the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable
-
-fn main() {}
+++ /dev/null
-error[E0658]: the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable (see issue #29642)
- --> $DIR/feature-gate-rustc-attrs-1.rs:15:1
- |
-LL | #[rustc_variance] //~ ERROR the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable
- | ^^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(rustc_attrs)] to the crate attributes to enable
-
-error[E0658]: the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable (see issue #29642)
- --> $DIR/feature-gate-rustc-attrs-1.rs:16:1
- |
-LL | #[rustc_error] //~ ERROR the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable
- | ^^^^^^^^^^^^^^
- |
- = help: add #![feature(rustc_attrs)] to the crate attributes to enable
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub mod foo {
- pub use bar::Bar;
- //~^ ERROR unresolved import `bar`
-
- pub mod bar {
- pub struct Bar;
- }
-}
-
-fn main() {
- let _ = foo::Bar;
-}
+++ /dev/null
-error[E0432]: unresolved import `bar`
- --> $DIR/feature-gate-uniform-paths.rs:12:13
- |
-LL | pub use bar::Bar;
- | ^^^ Did you mean `self::bar`?
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0432`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(custom_attribute)]
-
-#[my_attr(a b c d)]
-//~^ ERROR expected one of `(`, `)`, `,`, `::`, or `=`, found `b`
-//~| ERROR expected one of `(`, `)`, `,`, `::`, or `=`, found `c`
-//~| ERROR expected one of `(`, `)`, `,`, `::`, or `=`, found `d`
-fn main() {}
+++ /dev/null
-error: expected one of `(`, `)`, `,`, `::`, or `=`, found `b`
- --> $DIR/feature-gate-unrestricted-attribute-tokens.rs:13:13
- |
-LL | #[my_attr(a b c d)]
- | ^ expected one of `(`, `)`, `,`, `::`, or `=` here
-
-error: expected one of `(`, `)`, `,`, `::`, or `=`, found `c`
- --> $DIR/feature-gate-unrestricted-attribute-tokens.rs:13:15
- |
-LL | #[my_attr(a b c d)]
- | ^ expected one of `(`, `)`, `,`, `::`, or `=` here
-
-error: expected one of `(`, `)`, `,`, `::`, or `=`, found `d`
- --> $DIR/feature-gate-unrestricted-attribute-tokens.rs:13:17
- |
-LL | #[my_attr(a b c d)]
- | ^ expected one of `(`, `)`, `,`, `::`, or `=` here
-
-error: aborting due to 3 previous errors
-
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-tidy-linelength
+
+// Test that `#[rustc_*]` attributes are gated by `rustc_attrs` feature gate.
+
+#[rustc_variance] //~ ERROR the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable
+#[rustc_error] //~ ERROR the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable
+
+fn main() {}
--- /dev/null
+error[E0658]: the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable (see issue #29642)
+ --> $DIR/feature-gate-rustc-attrs-1.rs:15:1
+ |
+LL | #[rustc_variance] //~ ERROR the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable
+ | ^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(rustc_attrs)] to the crate attributes to enable
+
+error[E0658]: the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable (see issue #29642)
+ --> $DIR/feature-gate-rustc-attrs-1.rs:16:1
+ |
+LL | #[rustc_error] //~ ERROR the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable
+ | ^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(rustc_attrs)] to the crate attributes to enable
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub mod foo {
+ pub use bar::Bar;
+ //~^ ERROR unresolved import `bar`
+
+ pub mod bar {
+ pub struct Bar;
+ }
+}
+
+fn main() {
+ let _ = foo::Bar;
+}
--- /dev/null
+error[E0432]: unresolved import `bar`
+ --> $DIR/feature-gate-uniform-paths.rs:12:13
+ |
+LL | pub use bar::Bar;
+ | ^^^ Did you mean `self::bar`?
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0432`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(custom_attribute)]
+
+#[my_attr(a b c d)]
+//~^ ERROR expected one of `(`, `)`, `,`, `::`, or `=`, found `b`
+//~| ERROR expected one of `(`, `)`, `,`, `::`, or `=`, found `c`
+//~| ERROR expected one of `(`, `)`, `,`, `::`, or `=`, found `d`
+fn main() {}
--- /dev/null
+error: expected one of `(`, `)`, `,`, `::`, or `=`, found `b`
+ --> $DIR/feature-gate-unrestricted-attribute-tokens.rs:13:13
+ |
+LL | #[my_attr(a b c d)]
+ | ^ expected one of `(`, `)`, `,`, `::`, or `=` here
+
+error: expected one of `(`, `)`, `,`, `::`, or `=`, found `c`
+ --> $DIR/feature-gate-unrestricted-attribute-tokens.rs:13:15
+ |
+LL | #[my_attr(a b c d)]
+ | ^ expected one of `(`, `)`, `,`, `::`, or `=` here
+
+error: expected one of `(`, `)`, `,`, `::`, or `=`, found `d`
+ --> $DIR/feature-gate-unrestricted-attribute-tokens.rs:13:17
+ |
+LL | #[my_attr(a b c d)]
+ | ^ expected one of `(`, `)`, `,`, `::`, or `=` here
+
+error: aborting due to 3 previous errors
+
LL | fn hash(&self, hasher: &mut impl Hasher) {}
| ^^^^^^^^^^^ expected generic parameter, found `impl Trait`
|
- ::: $SRC_DIR/libcore/hash/mod.rs:185:13
+ ::: $SRC_DIR/libcore/hash/mod.rs:LL:COL
|
LL | fn hash<H: Hasher>(&self, state: &mut H);
| - declaration in trait here
--> $DIR/unboxed-closure-sugar-wrong-trait.rs:15:13
|
LL | fn f<F:Trait(isize) -> isize>(x: F) {}
- | ^^^^^^^^^^^^^^^^ unexpected type argument
+ | ^^^^^^^ unexpected type argument
error[E0220]: associated type `Output` not found for `Trait`
--> $DIR/unboxed-closure-sugar-wrong-trait.rs:15:24
normalized = normalized.replace("\\n", "\n");
}
+ // If there are `$SRC_DIR` normalizations with line and column numbers, then replace them
+ // with placeholders as we do not want tests needing updated when compiler source code
+ // changes.
+ // eg. $SRC_DIR/libcore/mem.rs:323:14 becomes $SRC_DIR/libcore/mem.rs:LL:COL
+ normalized = Regex::new("SRC_DIR(.+):\\d+:\\d+").unwrap()
+ .replace_all(&normalized, "SRC_DIR$1:LL:COL").into_owned();
+
normalized = normalized.replace("\\\\", "\\") // denormalize for paths on windows
.replace("\\", "/") // normalize for paths on windows
.replace("\r\n", "\n") // normalize for linebreaks on windows
projects / rust.git / commitdiff