use crate::hir::{GenericArg, ConstArg};
use crate::hir::ptr::P;
use crate::lint;
-use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
- ELIDED_LIFETIMES_IN_PATHS};
+use crate::lint::builtin::{self, ELIDED_LIFETIMES_IN_PATHS};
use crate::middle::cstore::CrateStore;
use crate::session::Session;
use crate::session::config::nightly_options;
use syntax_pos::hygiene::ExpnId;
use syntax_pos::Span;
+use rustc_error_codes::*;
+
const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF;
pub struct LoweringContext<'a> {
) -> (ast::Path, Res<NodeId>);
fn lint_buffer(&mut self) -> &mut lint::LintBuffer;
+
+ fn next_node_id(&mut self) -> NodeId;
}
type NtToTokenstream = fn(&Nonterminal, &ParseSess, Span) -> TokenStream;
enum ParenthesizedGenericArgs {
Ok,
- Warn,
Err,
}
| ItemKind::Union(_, ref generics)
| ItemKind::Enum(_, ref generics)
| ItemKind::TyAlias(_, ref generics)
- | ItemKind::OpaqueTy(_, ref generics)
| ItemKind::Trait(_, _, ref generics, ..) => {
let def_id = self.lctx.resolver.definitions().local_def_id(item.id);
let count = generics
}
fn next_id(&mut self) -> hir::HirId {
- self.lower_node_id(self.sess.next_node_id())
+ let node_id = self.resolver.next_node_id();
+ self.lower_node_id(node_id)
}
fn lower_res(&mut self, res: Res<NodeId>) -> Res {
hir_name: ParamName,
parent_index: DefIndex,
) -> hir::GenericParam {
- let node_id = self.sess.next_node_id();
+ let node_id = self.resolver.next_node_id();
// Get the name we'll use to make the def-path. Note
// that collisions are ok here and this shouldn't
// Desugar `AssocTy: Bounds` into `AssocTy = impl Bounds`. We do this by
// constructing the HIR for `impl bounds...` and then lowering that.
- let impl_trait_node_id = self.sess.next_node_id();
+ let impl_trait_node_id = self.resolver.next_node_id();
let parent_def_index = self.current_hir_id_owner.last().unwrap().0;
self.resolver.definitions().create_def_with_parent(
parent_def_index,
);
self.with_dyn_type_scope(false, |this| {
+ let node_id = this.resolver.next_node_id();
let ty = this.lower_ty(
&Ty {
- id: this.sess.next_node_id(),
+ id: node_id,
kind: TyKind::ImplTrait(impl_trait_node_id, bounds.clone()),
span: constraint.span,
},
&NodeMap::default(),
ImplTraitContext::disallowed(),
),
- unsafety: this.lower_unsafety(f.unsafety),
+ unsafety: f.unsafety,
abi: this.lower_abi(f.abi),
decl: this.lower_fn_decl(&f.decl, None, false, None),
param_names: this.lower_fn_params_to_names(&f.decl),
name,
}));
- let def_node_id = self.context.sess.next_node_id();
+ let def_node_id = self.context.resolver.next_node_id();
let hir_id =
self.context.lower_node_id_with_owner(def_node_id, self.opaque_ty_id);
self.context.resolver.definitions().create_def_with_parent(
};
let parenthesized_generic_args = match partial_res.base_res() {
// `a::b::Trait(Args)`
- Res::Def(DefKind::Trait, _)
- if i + 1 == proj_start => ParenthesizedGenericArgs::Ok,
+ Res::Def(DefKind::Trait, _) if i + 1 == proj_start => {
+ ParenthesizedGenericArgs::Ok
+ }
// `a::b::Trait(Args)::TraitItem`
- Res::Def(DefKind::Method, _)
- | Res::Def(DefKind::AssocConst, _)
- | Res::Def(DefKind::AssocTy, _)
- if i + 2 == proj_start =>
- {
+ Res::Def(DefKind::Method, _) |
+ Res::Def(DefKind::AssocConst, _) |
+ Res::Def(DefKind::AssocTy, _) if i + 2 == proj_start => {
ParenthesizedGenericArgs::Ok
}
// Avoid duplicated errors.
Res::Err => ParenthesizedGenericArgs::Ok,
// An error
- Res::Def(DefKind::Struct, _)
- | Res::Def(DefKind::Enum, _)
- | Res::Def(DefKind::Union, _)
- | Res::Def(DefKind::TyAlias, _)
- | Res::Def(DefKind::Variant, _) if i + 1 == proj_start =>
- {
- ParenthesizedGenericArgs::Err
- }
- // A warning for now, for compatibility reasons.
- _ => ParenthesizedGenericArgs::Warn,
+ _ => ParenthesizedGenericArgs::Err,
};
let num_lifetimes = type_def_id.map_or(0, |def_id| {
segment,
param_mode,
0,
- ParenthesizedGenericArgs::Warn,
+ ParenthesizedGenericArgs::Err,
itctx.reborrow(),
None,
));
}
GenericArgs::Parenthesized(ref data) => match parenthesized_generic_args {
ParenthesizedGenericArgs::Ok => self.lower_parenthesized_parameter_data(data),
- ParenthesizedGenericArgs::Warn => {
- self.resolver.lint_buffer().buffer_lint(
- PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
- CRATE_NODE_ID,
- data.span,
- msg.into(),
- );
- (hir::GenericArgs::none(), true)
- }
ParenthesizedGenericArgs::Err => {
let mut err = struct_span_err!(self.sess, data.span, E0214, "{}", msg);
err.span_label(data.span, "only `Fn` traits may use parentheses");
if let Ok(snippet) = self.sess.source_map().span_to_snippet(data.span) {
// Do not suggest going from `Trait()` to `Trait<>`
if data.inputs.len() > 0 {
- let split = snippet.find('(').unwrap();
- let trait_name = &snippet[0..split];
- let args = &snippet[split + 1 .. snippet.len() - 1];
- err.span_suggestion(
- data.span,
- "use angle brackets instead",
- format!("{}<{}>", trait_name, args),
- Applicability::MaybeIncorrect,
- );
+ if let Some(split) = snippet.find('(') {
+ let trait_name = &snippet[0..split];
+ let args = &snippet[split + 1 .. snippet.len() - 1];
+ err.span_suggestion(
+ data.span,
+ "use angle brackets instead",
+ format!("{}<{}>", trait_name, args),
+ Applicability::MaybeIncorrect,
+ );
+ }
}
};
err.emit();
}, ids)
}
- fn lower_mutability(&mut self, m: Mutability) -> hir::Mutability {
- match m {
- Mutability::Mutable => hir::MutMutable,
- Mutability::Immutable => hir::MutImmutable,
- }
- }
-
fn lower_fn_params_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Ident> {
// Skip the `...` (`CVarArgs`) trailing arguments from the AST,
// as they are not explicit in HIR/Ty function signatures.
fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_>) -> hir::MutTy {
hir::MutTy {
ty: self.lower_ty(&mt.ty, itctx),
- mutbl: self.lower_mutability(mt.mutbl),
+ mutbl: mt.mutbl,
}
}
}
PatKind::Box(ref inner) => hir::PatKind::Box(self.lower_pat(inner)),
PatKind::Ref(ref inner, mutbl) => {
- hir::PatKind::Ref(self.lower_pat(inner), self.lower_mutability(mutbl))
+ hir::PatKind::Ref(self.lower_pat(inner), mutbl)
}
PatKind::Range(ref e1, ref e2, Spanned { node: ref end, .. }) => hir::PatKind::Range(
P(self.lower_expr(e1)),
Some(id) => (id, "`'_` cannot be used here", "`'_` is a reserved lifetime name"),
None => (
- self.sess.next_node_id(),
+ self.resolver.next_node_id(),
"`&` without an explicit lifetime name cannot be used here",
"explicit lifetime name needed here",
),
span,
"expected 'implicit elided lifetime not allowed' error",
);
- let id = self.sess.next_node_id();
+ let id = self.resolver.next_node_id();
self.new_named_lifetime(id, span, hir::LifetimeName::Error)
}
// `PassThrough` is the normal case.
projects / rust.git / blobdiff