use crate::lint;
use crate::middle::resolve_lifetime as rl;
use crate::middle::weak_lang_items;
+use errors::{struct_span_err, Applicability, StashKey};
+use rustc::hir::map::Map;
+use rustc::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
use rustc::mir::mono::Linkage;
+use rustc::traits;
use rustc::ty::query::Providers;
use rustc::ty::subst::GenericArgKind;
use rustc::ty::subst::{InternalSubsts, Subst};
use rustc::ty::{self, AdtKind, Const, DefIdTree, ToPolyTraitRef, Ty, TyCtxt};
use rustc::ty::{ReprOptions, ToPredicate};
use rustc::util::captures::Captures;
-use rustc::util::nodemap::FxHashMap;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
+use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{GenericParamKind, Node, Unsafety};
+use rustc_span::symbol::{kw, sym, Symbol};
+use rustc_span::{Span, DUMMY_SP};
use rustc_target::spec::abi;
-
use syntax::ast;
use syntax::ast::{Ident, MetaItemKind};
use syntax::attr::{list_contains_name, mark_used, InlineAttr, OptimizeAttr};
use syntax::feature_gate;
-use syntax::symbol::{kw, sym, Symbol};
-use syntax_pos::{Span, DUMMY_SP};
-
-use rustc::hir::def::{CtorKind, DefKind, Res};
-use rustc::hir::def_id::{DefId, LOCAL_CRATE};
-use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc::hir::GenericParamKind;
-use rustc::hir::Node;
-use rustc::hir::{self, CodegenFnAttrFlags, CodegenFnAttrs, Unsafety};
-
-use errors::{Applicability, StashKey};
use rustc_error_codes::*;
///////////////////////////////////////////////////////////////////////////
+#[derive(Default)]
+crate struct PlaceholderHirTyCollector(crate Vec<Span>);
+
+impl<'v> Visitor<'v> for PlaceholderHirTyCollector {
+ type Map = Map<'v>;
+
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
+ NestedVisitorMap::None
+ }
+ fn visit_ty(&mut self, t: &'v hir::Ty<'v>) {
+ if let hir::TyKind::Infer = t.kind {
+ self.0.push(t.span);
+ }
+ intravisit::walk_ty(self, t)
+ }
+}
+
struct CollectItemTypesVisitor<'tcx> {
tcx: TyCtxt<'tcx>,
}
+/// If there are any placeholder types (`_`), emit an error explaining that this is not allowed
+/// and suggest adding type parameters in the appropriate place, taking into consideration any and
+/// all already existing generic type parameters to avoid suggesting a name that is already in use.
+crate fn placeholder_type_error(
+ tcx: TyCtxt<'tcx>,
+ ident_span: Span,
+ generics: &[hir::GenericParam<'_>],
+ placeholder_types: Vec<Span>,
+ suggest: bool,
+) {
+ if placeholder_types.is_empty() {
+ return;
+ }
+ // This is the whitelist of possible parameter names that we might suggest.
+ let possible_names = ["T", "K", "L", "A", "B", "C"];
+ let used_names = generics
+ .iter()
+ .filter_map(|p| match p.name {
+ hir::ParamName::Plain(ident) => Some(ident.name),
+ _ => None,
+ })
+ .collect::<Vec<_>>();
+
+ let type_name = possible_names
+ .iter()
+ .find(|n| !used_names.contains(&Symbol::intern(n)))
+ .unwrap_or(&"ParamName");
+
+ let mut sugg: Vec<_> =
+ placeholder_types.iter().map(|sp| (*sp, type_name.to_string())).collect();
+ if generics.is_empty() {
+ sugg.push((ident_span.shrink_to_hi(), format!("<{}>", type_name)));
+ } else {
+ sugg.push((
+ generics.iter().last().unwrap().span.shrink_to_hi(),
+ format!(", {}", type_name),
+ ));
+ }
+ let mut err = bad_placeholder_type(tcx, placeholder_types);
+ if suggest {
+ err.multipart_suggestion(
+ "use type parameters instead",
+ sugg,
+ Applicability::HasPlaceholders,
+ );
+ }
+ err.emit();
+}
+
+fn reject_placeholder_type_signatures_in_item(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) {
+ let (generics, suggest) = match &item.kind {
+ hir::ItemKind::Union(_, generics)
+ | hir::ItemKind::Enum(_, generics)
+ | hir::ItemKind::Struct(_, generics) => (&generics.params[..], true),
+ hir::ItemKind::TyAlias(_, generics) => (&generics.params[..], false),
+ // `static`, `fn` and `const` are handled elsewhere to suggest appropriate type.
+ _ => return,
+ };
+
+ let mut visitor = PlaceholderHirTyCollector::default();
+ visitor.visit_item(item);
+
+ placeholder_type_error(tcx, item.ident.span, generics, visitor.0, suggest);
+}
+
impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+ type Map = Map<'tcx>;
+
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
NestedVisitorMap::OnlyBodies(&self.tcx.hir())
}
fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
convert_item(self.tcx, item.hir_id);
+ reject_placeholder_type_signatures_in_item(self.tcx, item);
intravisit::walk_item(self, item);
}
///////////////////////////////////////////////////////////////////////////
// Utility types and common code for the above passes.
-fn bad_placeholder_type(tcx: TyCtxt<'tcx>, span: Span) -> errors::DiagnosticBuilder<'tcx> {
- let mut diag = struct_span_err!(
+fn bad_placeholder_type(
+ tcx: TyCtxt<'tcx>,
+ mut spans: Vec<Span>,
+) -> errors::DiagnosticBuilder<'tcx> {
+ spans.sort();
+ let mut err = struct_span_err!(
tcx.sess,
- span,
+ spans.clone(),
E0121,
"the type placeholder `_` is not allowed within types on item signatures",
);
- diag.span_label(span, "not allowed in type signatures");
- diag
+ for span in spans {
+ err.span_label(span, "not allowed in type signatures");
+ }
+ err
}
impl ItemCtxt<'tcx> {
None
}
- fn ty_infer(&self, _: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
- bad_placeholder_type(self.tcx(), span).emit();
+ fn allow_ty_infer(&self) -> bool {
+ false
+ }
+ fn ty_infer(&self, _: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
+ self.tcx().sess.delay_span_bug(span, "bad placeholder type");
self.tcx().types.err
}
_: Option<&ty::GenericParamDef>,
span: Span,
) -> &'tcx Const<'tcx> {
- bad_placeholder_type(self.tcx(), span).emit();
+ bad_placeholder_type(self.tcx(), vec![span]).emit();
self.tcx().consts.err
}
self.tcx().mk_projection(item_def_id, item_substs)
} else {
// There are no late-bound regions; we can just ignore the binder.
- span_err!(
+ struct_span_err!(
self.tcx().sess,
span,
E0212,
"cannot extract an associated type from a higher-ranked trait bound \
in this context"
- );
+ )
+ .emit();
self.tcx().types.err
}
}
tcx: TyCtxt<'_>,
(item_def_id, def_id): (DefId, DefId),
) -> ty::GenericPredicates<'_> {
- use rustc::hir::*;
+ use rustc_hir::*;
// In the AST, bounds can derive from two places. Either
// written inline like `<T: Foo>` or in a where-clause like
}
fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef {
- use rustc::hir::*;
+ use rustc_hir::*;
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
let item = match tcx.hir().get(hir_id) {
let paren_sugar = tcx.has_attr(def_id, sym::rustc_paren_sugar);
if paren_sugar && !tcx.features().unboxed_closures {
- let mut err = tcx.sess.struct_span_err(
- item.span,
- "the `#[rustc_paren_sugar]` attribute is a temporary means of controlling \
+ tcx.sess
+ .struct_span_err(
+ item.span,
+ "the `#[rustc_paren_sugar]` attribute is a temporary means of controlling \
which traits can use parenthetical notation",
- );
- help!(
- &mut err,
- "add `#![feature(unboxed_closures)]` to \
- the crate attributes to use it"
- );
- err.emit();
+ )
+ .help("add `#![feature(unboxed_closures)]` to the crate attributes to use it")
+ .emit();
}
let is_marker = tcx.has_attr(def_id, sym::marker);
}
impl Visitor<'tcx> for LateBoundRegionsDetector<'tcx> {
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+ type Map = Map<'tcx>;
+
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
NestedVisitorMap::None
}
}
fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics {
- use rustc::hir::*;
+ use rustc_hir::*;
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
}
fn report_assoc_ty_on_inherent_impl(tcx: TyCtxt<'_>, span: Span) {
- span_err!(
+ struct_span_err!(
tcx.sess,
span,
E0202,
"associated types are not yet supported in inherent impls (see #8995)"
- );
+ )
+ .emit();
}
fn infer_placeholder_type(
span: Span,
item_ident: Ident,
) -> Ty<'_> {
- let ty = tcx.typeck_tables_of(def_id).node_type(body_id.hir_id);
+ let ty = tcx.diagnostic_only_typeck_tables_of(def_id).node_type(body_id.hir_id);
// If this came from a free `const` or `static mut?` item,
// then the user may have written e.g. `const A = 42;`.
.emit();
}
None => {
- let mut diag = bad_placeholder_type(tcx, span);
+ let mut diag = bad_placeholder_type(tcx, vec![span]);
if ty != tcx.types.err {
diag.span_suggestion(
span,
}
fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
- use rustc::hir::*;
+ use rustc_hir::*;
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
}
TraitItemKind::Const(ref ty, body_id) => body_id
.and_then(|body_id| {
- if let hir::TyKind::Infer = ty.kind {
+ if is_suggestable_infer_ty(ty) {
Some(infer_placeholder_type(tcx, def_id, body_id, ty.span, item.ident))
} else {
None
tcx.mk_fn_def(def_id, substs)
}
ImplItemKind::Const(ref ty, body_id) => {
- if let hir::TyKind::Infer = ty.kind {
+ if is_suggestable_infer_ty(ty) {
infer_placeholder_type(tcx, def_id, body_id, ty.span, item.ident)
} else {
icx.to_ty(ty)
Node::Item(item) => {
match item.kind {
ItemKind::Static(ref ty, .., body_id) | ItemKind::Const(ref ty, body_id) => {
- if let hir::TyKind::Infer = ty.kind {
+ if is_suggestable_infer_ty(ty) {
infer_placeholder_type(tcx, def_id, body_id, ty.span, item.ident)
} else {
icx.to_ty(ty)
}
}
- Node::GenericParam(param) => {
- match ¶m.kind {
- hir::GenericParamKind::Type { default: Some(ref ty), .. } => icx.to_ty(ty),
- hir::GenericParamKind::Const { ty: ref hir_ty, .. } => {
- let ty = icx.to_ty(hir_ty);
- if !tcx.features().const_compare_raw_pointers {
- let err = match ty.peel_refs().kind {
- ty::FnPtr(_) => Some("function pointers"),
- ty::RawPtr(_) => Some("raw pointers"),
- _ => None,
- };
- if let Some(unsupported_type) = err {
- feature_gate::feature_err(
- &tcx.sess.parse_sess,
- sym::const_compare_raw_pointers,
- hir_ty.span,
- &format!(
- "using {} as const generic parameters is unstable",
- unsupported_type
- ),
- )
- .emit();
- };
- }
- if ty::search_for_structural_match_violation(param.hir_id, param.span, tcx, ty)
- .is_some()
- {
- struct_span_err!(
+ Node::GenericParam(param) => match ¶m.kind {
+ hir::GenericParamKind::Type { default: Some(ref ty), .. } => icx.to_ty(ty),
+ hir::GenericParamKind::Const { ty: ref hir_ty, .. } => {
+ let ty = icx.to_ty(hir_ty);
+ if !tcx.features().const_compare_raw_pointers {
+ let err = match ty.peel_refs().kind {
+ ty::FnPtr(_) => Some("function pointers"),
+ ty::RawPtr(_) => Some("raw pointers"),
+ _ => None,
+ };
+ if let Some(unsupported_type) = err {
+ feature_gate::feature_err(
+ &tcx.sess.parse_sess,
+ sym::const_compare_raw_pointers,
+ hir_ty.span,
+ &format!(
+ "using {} as const generic parameters is unstable",
+ unsupported_type
+ ),
+ )
+ .emit();
+ };
+ }
+ if traits::search_for_structural_match_violation(param.hir_id, param.span, tcx, ty)
+ .is_some()
+ {
+ struct_span_err!(
tcx.sess,
hir_ty.span,
E0741,
"the types of const generic parameters must derive `PartialEq` and `Eq`",
- ).span_label(
+ )
+ .span_label(
hir_ty.span,
format!("`{}` doesn't derive both `PartialEq` and `Eq`", ty),
- ).emit();
- }
- ty
+ )
+ .emit();
}
- x => bug!("unexpected non-type Node::GenericParam: {:?}", x),
+ ty
}
- }
+ x => bug!("unexpected non-type Node::GenericParam: {:?}", x),
+ },
x => {
bug!("unexpected sort of node in type_of_def_id(): {:?}", x);
}
fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
- use rustc::hir::{ImplItem, Item, TraitItem};
+ use rustc_hir::{ImplItem, Item, TraitItem};
debug!("find_opaque_ty_constraints({:?})", def_id);
}
impl<'tcx> intravisit::Visitor<'tcx> for ConstraintLocator<'tcx> {
- fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> {
+ type Map = Map<'tcx>;
+
+ fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<'_, Self::Map> {
intravisit::NestedVisitorMap::All(&self.tcx.hir())
}
fn visit_item(&mut self, it: &'tcx Item<'tcx>) {
}
}
+/// Whether `ty` is a type with `_` placeholders that can be infered. Used in diagnostics only to
+/// use inference to provide suggestions for the appropriate type if possible.
+fn is_suggestable_infer_ty(ty: &hir::Ty<'_>) -> bool {
+ match &ty.kind {
+ hir::TyKind::Infer => true,
+ hir::TyKind::Slice(ty) | hir::TyKind::Array(ty, _) => is_suggestable_infer_ty(ty),
+ hir::TyKind::Tup(tys) => tys.iter().any(|ty| is_suggestable_infer_ty(ty)),
+ _ => false,
+ }
+}
+
pub fn get_infer_ret_ty(output: &'hir hir::FunctionRetTy<'hir>) -> Option<&'hir hir::Ty<'hir>> {
if let hir::FunctionRetTy::Return(ref ty) = output {
- if let hir::TyKind::Infer = ty.kind {
+ if is_suggestable_infer_ty(ty) {
return Some(&**ty);
}
}
}
fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> {
- use rustc::hir::Node::*;
- use rustc::hir::*;
+ use rustc_hir::Node::*;
+ use rustc_hir::*;
let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
match tcx.hir().get(hir_id) {
TraitItem(hir::TraitItem {
kind: TraitItemKind::Method(sig, TraitMethod::Provided(_)),
+ ident,
+ generics,
..
})
- | ImplItem(hir::ImplItem { kind: ImplItemKind::Method(sig, _), .. })
- | Item(hir::Item { kind: ItemKind::Fn(sig, _, _), .. }) => {
+ | ImplItem(hir::ImplItem { kind: ImplItemKind::Method(sig, _), ident, generics, .. })
+ | Item(hir::Item { kind: ItemKind::Fn(sig, generics, _), ident, .. }) => {
match get_infer_ret_ty(&sig.decl.output) {
Some(ty) => {
let fn_sig = tcx.typeck_tables_of(def_id).liberated_fn_sigs()[hir_id];
- let mut diag = bad_placeholder_type(tcx, ty.span);
+ let mut visitor = PlaceholderHirTyCollector::default();
+ visitor.visit_ty(ty);
+ let mut diag = bad_placeholder_type(tcx, visitor.0);
let ret_ty = fn_sig.output();
if ret_ty != tcx.types.err {
diag.span_suggestion(
ty.span,
- "replace `_` with the correct return type",
+ "replace with the correct return type",
ret_ty.to_string(),
Applicability::MaybeIncorrect,
);
diag.emit();
ty::Binder::bind(fn_sig)
}
- None => AstConv::ty_of_fn(&icx, sig.header.unsafety, sig.header.abi, &sig.decl),
+ None => AstConv::ty_of_fn(
+ &icx,
+ sig.header.unsafety,
+ sig.header.abi,
+ &sig.decl,
+ &generics.params[..],
+ Some(ident.span),
+ ),
}
}
TraitItem(hir::TraitItem {
kind: TraitItemKind::Method(FnSig { header, decl }, _),
+ ident,
+ generics,
..
- }) => AstConv::ty_of_fn(&icx, header.unsafety, header.abi, decl),
+ }) => AstConv::ty_of_fn(
+ &icx,
+ header.unsafety,
+ header.abi,
+ decl,
+ &generics.params[..],
+ Some(ident.span),
+ ),
ForeignItem(&hir::ForeignItem { kind: ForeignItemKind::Fn(ref fn_decl, _, _), .. }) => {
let abi = tcx.hir().get_foreign_abi(hir_id);
/// Returns a list of user-specified type predicates for the definition with ID `def_id`.
/// N.B., this does not include any implied/inferred constraints.
fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
- use rustc::hir::*;
use rustc_data_structures::fx::FxHashSet;
+ use rustc_hir::*;
debug!("explicit_predicates_of(def_id={:?})", def_id);
} else {
hir::Unsafety::Unsafe
};
- let fty = AstConv::ty_of_fn(&ItemCtxt::new(tcx, def_id), unsafety, abi, decl);
+ let fty = AstConv::ty_of_fn(&ItemCtxt::new(tcx, def_id), unsafety, abi, decl, &[], None);
// Feature gate SIMD types in FFI, since I am not sure that the
// ABIs are handled at all correctly. -huonw
for (input, ty) in decl.inputs.iter().zip(*fty.inputs().skip_binder()) {
check(&input, ty)
}
- if let hir::Return(ref ty) = decl.output {
+ if let hir::FunctionRetTy::Return(ref ty) = decl.output {
check(&ty, *fty.output().skip_binder())
}
}
mark_used(attr);
inline_span = Some(attr.span);
if items.len() != 1 {
- span_err!(tcx.sess.diagnostic(), attr.span, E0534, "expected one argument");
+ struct_span_err!(
+ tcx.sess.diagnostic(),
+ attr.span,
+ E0534,
+ "expected one argument"
+ )
+ .emit();
InlineAttr::None
} else if list_contains_name(&items[..], sym::always) {
InlineAttr::Always
} else if list_contains_name(&items[..], sym::never) {
InlineAttr::Never
} else {
- span_err!(tcx.sess.diagnostic(), items[0].span(), E0535, "invalid argument");
+ struct_span_err!(
+ tcx.sess.diagnostic(),
+ items[0].span(),
+ E0535,
+ "invalid argument"
+ )
+ .emit();
InlineAttr::None
}
if !attr.has_name(sym::optimize) {
return ia;
}
- let err = |sp, s| span_err!(tcx.sess.diagnostic(), sp, E0722, "{}", s);
+ let err = |sp, s| struct_span_err!(tcx.sess.diagnostic(), sp, E0722, "{}", s).emit();
match attr.meta().map(|i| i.kind) {
Some(MetaItemKind::Word) => {
err(attr.span, "expected one argument");
projects / rust.git / blobdiff