&self,
res: Res,
span: Span,
- ) -> Result<(DefKind, DefId, Ty<'tcx>), ErrorReported> {
+ ) -> Result<Res, ErrorReported> {
let tcx = self.tcx;
if let Res::SelfCtor(impl_def_id) = res {
let ty = self.impl_self_ty(span, impl_def_id).ty;
Some(adt_def) if adt_def.has_ctor() => {
let variant = adt_def.non_enum_variant();
let ctor_def_id = variant.ctor_def_id.unwrap();
- Ok((
- DefKind::Ctor(CtorOf::Struct, variant.ctor_kind),
- ctor_def_id,
- tcx.type_of(ctor_def_id),
- ))
+ Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
}
_ => {
let mut err = tcx.sess.struct_span_err(span,
}
}
} else {
- match res {
- Res::Def(kind, def_id) => {
- // The things we are substituting into the type should not contain
- // escaping late-bound regions, and nor should the base type scheme.
- let ty = tcx.type_of(def_id);
- Ok((kind, def_id, ty))
- }
- _ => span_bug!(span, "unexpected res in rewrite_self_ctor: {:?}", res),
- }
+ Ok(res)
}
}
let tcx = self.tcx;
- match res {
- Res::Local(hid) | Res::Upvar(hid, ..) => {
- let ty = self.local_ty(span, hid).decl_ty;
- let ty = self.normalize_associated_types_in(span, &ty);
- self.write_ty(hir_id, ty);
- return (ty, res);
- }
- _ => {}
- }
-
- let (kind, def_id, ty) = match self.rewrite_self_ctor(res, span) {
- Ok(result) => result,
+ let res = match self.rewrite_self_ctor(res, span) {
+ Ok(res) => res,
Err(ErrorReported) => return (tcx.types.err, res),
};
- let path_segs =
- AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id);
+ let path_segs = match res {
+ Res::Local(_) | Res::Upvar(..) => Vec::new(),
+ Res::Def(kind, def_id) =>
+ AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
+ _ => bug!("instantiate_value_path on {:?}", res),
+ };
let mut user_self_ty = None;
let mut is_alias_variant_ctor = false;
- match kind {
- DefKind::Ctor(CtorOf::Variant, _) => {
+ match res {
+ Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
if let Some(self_ty) = self_ty {
let adt_def = self_ty.ty_adt_def().unwrap();
user_self_ty = Some(UserSelfTy {
is_alias_variant_ctor = true;
}
}
- DefKind::Method
- | DefKind::AssociatedConst => {
+ Res::Def(DefKind::Method, def_id)
+ | Res::Def(DefKind::AssociatedConst, def_id) => {
let container = tcx.associated_item(def_id).container;
debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
match container {
None
}
}));
+
+ match res {
+ Res::Local(hid) | Res::Upvar(hid, ..) => {
+ let ty = self.local_ty(span, hid).decl_ty;
+ let ty = self.normalize_associated_types_in(span, &ty);
+ self.write_ty(hir_id, ty);
+ return (ty, res);
+ }
+ _ => {}
+ }
+
if generics_has_err {
// Don't try to infer type parameters when prohibited generic arguments were given.
user_self_ty = None;
tcx.generics_of(*def_id).has_self
}).unwrap_or(false);
+ let def_id = res.def_id();
+
+ // The things we are substituting into the type should not contain
+ // escaping late-bound regions, and nor should the base type scheme.
+ let ty = tcx.type_of(def_id);
+
let substs = AstConv::create_substs_for_generic_args(
tcx,
def_id,
ty_substituted);
self.write_substs(hir_id, substs);
- (ty_substituted, Res::Def(kind, def_id))
+ (ty_substituted, res)
}
fn check_rustc_args_require_const(&self,