]>
Commit | Line | Data |
---|---|---|
1b1a35ee | 1 | use rustc_errors::{Applicability, ErrorReported, StashKey}; |
74b04a01 XL |
2 | use rustc_hir as hir; |
3 | use rustc_hir::def::{DefKind, Res}; | |
f9f354fc | 4 | use rustc_hir::def_id::{DefId, LocalDefId}; |
74b04a01 XL |
5 | use rustc_hir::intravisit; |
6 | use rustc_hir::intravisit::Visitor; | |
5869c6ff | 7 | use rustc_hir::{HirId, Node}; |
ba9703b0 | 8 | use rustc_middle::hir::map::Map; |
c295e0f8 | 9 | use rustc_middle::ty::subst::{InternalSubsts, SubstsRef}; |
ba9703b0 | 10 | use rustc_middle::ty::util::IntTypeExt; |
136023e0 | 11 | use rustc_middle::ty::{self, DefIdTree, Ty, TyCtxt, TypeFoldable, TypeFolder}; |
f035d41b | 12 | use rustc_span::symbol::Ident; |
74b04a01 XL |
13 | use rustc_span::{Span, DUMMY_SP}; |
14 | ||
15 | use super::ItemCtxt; | |
a2a8927a | 16 | use super::{bad_placeholder, is_suggestable_infer_ty}; |
74b04a01 | 17 | |
3dfed10e XL |
18 | /// Computes the relevant generic parameter for a potential generic const argument. |
19 | /// | |
20 | /// This should be called using the query `tcx.opt_const_param_of`. | |
21 | pub(super) fn opt_const_param_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<DefId> { | |
94222f64 XL |
22 | // FIXME(generic_arg_infer): allow for returning DefIds of inference of |
23 | // GenericArg::Infer below. This may require a change where GenericArg::Infer has some flag | |
24 | // for const or type. | |
3dfed10e | 25 | use hir::*; |
3dfed10e XL |
26 | let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); |
27 | ||
28 | if let Node::AnonConst(_) = tcx.hir().get(hir_id) { | |
29 | let parent_node_id = tcx.hir().get_parent_node(hir_id); | |
30 | let parent_node = tcx.hir().get(parent_node_id); | |
31 | ||
32 | match parent_node { | |
6a06907d XL |
33 | // This match arm is for when the def_id appears in a GAT whose |
34 | // path can't be resolved without typechecking e.g. | |
35 | // | |
36 | // trait Foo { | |
37 | // type Assoc<const N: usize>; | |
38 | // fn foo() -> Self::Assoc<3>; | |
39 | // } | |
40 | // | |
41 | // In the above code we would call this query with the def_id of 3 and | |
42 | // the parent_node we match on would be the hir node for Self::Assoc<3> | |
43 | // | |
44 | // `Self::Assoc<3>` cant be resolved without typchecking here as we | |
45 | // didnt write <Self as Foo>::Assoc<3>. If we did then another match | |
46 | // arm would handle this. | |
47 | // | |
48 | // I believe this match arm is only needed for GAT but I am not 100% sure - BoxyUwU | |
49 | Node::Ty(hir_ty @ Ty { kind: TyKind::Path(QPath::TypeRelative(_, segment)), .. }) => { | |
50 | // Find the Item containing the associated type so we can create an ItemCtxt. | |
51 | // Using the ItemCtxt convert the HIR for the unresolved assoc type into a | |
52 | // ty which is a fully resolved projection. | |
53 | // For the code example above, this would mean converting Self::Assoc<3> | |
54 | // into a ty::Projection(<Self as Foo>::Assoc<3>) | |
55 | let item_hir_id = tcx | |
56 | .hir() | |
57 | .parent_iter(hir_id) | |
58 | .filter(|(_, node)| matches!(node, Node::Item(_))) | |
59 | .map(|(id, _)| id) | |
60 | .next() | |
61 | .unwrap(); | |
62 | let item_did = tcx.hir().local_def_id(item_hir_id).to_def_id(); | |
63 | let item_ctxt = &ItemCtxt::new(tcx, item_did) as &dyn crate::astconv::AstConv<'_>; | |
64 | let ty = item_ctxt.ast_ty_to_ty(hir_ty); | |
65 | ||
66 | // Iterate through the generics of the projection to find the one that corresponds to | |
67 | // the def_id that this query was called with. We filter to only const args here as a | |
68 | // precaution for if it's ever allowed to elide lifetimes in GAT's. It currently isn't | |
69 | // but it can't hurt to be safe ^^ | |
70 | if let ty::Projection(projection) = ty.kind() { | |
71 | let generics = tcx.generics_of(projection.item_def_id); | |
72 | ||
73 | let arg_index = segment | |
74 | .args | |
75 | .and_then(|args| { | |
76 | args.args | |
77 | .iter() | |
78 | .filter(|arg| arg.is_const()) | |
79 | .position(|arg| arg.id() == hir_id) | |
80 | }) | |
81 | .unwrap_or_else(|| { | |
82 | bug!("no arg matching AnonConst in segment"); | |
83 | }); | |
84 | ||
85 | return generics | |
86 | .params | |
87 | .iter() | |
cdc7bbd5 | 88 | .filter(|param| matches!(param.kind, ty::GenericParamDefKind::Const { .. })) |
6a06907d XL |
89 | .nth(arg_index) |
90 | .map(|param| param.def_id); | |
91 | } | |
92 | ||
93 | // I dont think it's possible to reach this but I'm not 100% sure - BoxyUwU | |
94 | tcx.sess.delay_span_bug( | |
95 | tcx.def_span(def_id), | |
96 | "unexpected non-GAT usage of an anon const", | |
97 | ); | |
98 | return None; | |
99 | } | |
3dfed10e XL |
100 | Node::Expr(&Expr { |
101 | kind: | |
102 | ExprKind::MethodCall(segment, ..) | ExprKind::Path(QPath::TypeRelative(_, segment)), | |
103 | .. | |
104 | }) => { | |
105 | let body_owner = tcx.hir().local_def_id(tcx.hir().enclosing_body_owner(hir_id)); | |
106 | let tables = tcx.typeck(body_owner); | |
107 | // This may fail in case the method/path does not actually exist. | |
108 | // As there is no relevant param for `def_id`, we simply return | |
109 | // `None` here. | |
110 | let type_dependent_def = tables.type_dependent_def_id(parent_node_id)?; | |
111 | let idx = segment | |
112 | .args | |
113 | .and_then(|args| { | |
114 | args.args | |
115 | .iter() | |
116 | .filter(|arg| arg.is_const()) | |
117 | .position(|arg| arg.id() == hir_id) | |
118 | }) | |
119 | .unwrap_or_else(|| { | |
120 | bug!("no arg matching AnonConst in segment"); | |
121 | }); | |
122 | ||
123 | tcx.generics_of(type_dependent_def) | |
124 | .params | |
125 | .iter() | |
cdc7bbd5 | 126 | .filter(|param| matches!(param.kind, ty::GenericParamDefKind::Const { .. })) |
3dfed10e XL |
127 | .nth(idx) |
128 | .map(|param| param.def_id) | |
129 | } | |
130 | ||
131 | Node::Ty(&Ty { kind: TyKind::Path(_), .. }) | |
5869c6ff XL |
132 | | Node::Expr(&Expr { kind: ExprKind::Path(_) | ExprKind::Struct(..), .. }) |
133 | | Node::TraitRef(..) | |
134 | | Node::Pat(_) => { | |
3dfed10e XL |
135 | let path = match parent_node { |
136 | Node::Ty(&Ty { kind: TyKind::Path(QPath::Resolved(_, path)), .. }) | |
137 | | Node::TraitRef(&TraitRef { path, .. }) => &*path, | |
138 | Node::Expr(&Expr { | |
139 | kind: | |
140 | ExprKind::Path(QPath::Resolved(_, path)) | |
141 | | ExprKind::Struct(&QPath::Resolved(_, path), ..), | |
142 | .. | |
143 | }) => { | |
144 | let body_owner = | |
145 | tcx.hir().local_def_id(tcx.hir().enclosing_body_owner(hir_id)); | |
146 | let _tables = tcx.typeck(body_owner); | |
147 | &*path | |
148 | } | |
5869c6ff XL |
149 | Node::Pat(pat) => { |
150 | if let Some(path) = get_path_containing_arg_in_pat(pat, hir_id) { | |
151 | path | |
152 | } else { | |
153 | tcx.sess.delay_span_bug( | |
154 | tcx.def_span(def_id), | |
155 | &format!( | |
156 | "unable to find const parent for {} in pat {:?}", | |
157 | hir_id, pat | |
158 | ), | |
159 | ); | |
160 | return None; | |
161 | } | |
162 | } | |
1b1a35ee XL |
163 | _ => { |
164 | tcx.sess.delay_span_bug( | |
165 | tcx.def_span(def_id), | |
166 | &format!("unexpected const parent path {:?}", parent_node), | |
167 | ); | |
168 | return None; | |
169 | } | |
3dfed10e XL |
170 | }; |
171 | ||
172 | // We've encountered an `AnonConst` in some path, so we need to | |
173 | // figure out which generic parameter it corresponds to and return | |
174 | // the relevant type. | |
a2a8927a | 175 | let filtered = path |
3dfed10e XL |
176 | .segments |
177 | .iter() | |
178 | .filter_map(|seg| seg.args.map(|args| (args.args, seg))) | |
179 | .find_map(|(args, seg)| { | |
180 | args.iter() | |
181 | .filter(|arg| arg.is_const()) | |
182 | .position(|arg| arg.id() == hir_id) | |
183 | .map(|index| (index, seg)) | |
3dfed10e | 184 | }); |
a2a8927a XL |
185 | let (arg_index, segment) = match filtered { |
186 | None => { | |
187 | tcx.sess.delay_span_bug( | |
188 | tcx.def_span(def_id), | |
189 | "no arg matching AnonConst in path", | |
190 | ); | |
191 | return None; | |
192 | } | |
193 | Some(inner) => inner, | |
194 | }; | |
3dfed10e XL |
195 | |
196 | // Try to use the segment resolution if it is valid, otherwise we | |
197 | // default to the path resolution. | |
198 | let res = segment.res.filter(|&r| r != Res::Err).unwrap_or(path.res); | |
94222f64 | 199 | use def::CtorOf; |
3dfed10e | 200 | let generics = match res { |
94222f64 XL |
201 | Res::Def(DefKind::Ctor(CtorOf::Variant, _), def_id) => tcx.generics_of( |
202 | tcx.parent(def_id).and_then(|def_id| tcx.parent(def_id)).unwrap(), | |
203 | ), | |
204 | Res::Def(DefKind::Variant | DefKind::Ctor(CtorOf::Struct, _), def_id) => { | |
3dfed10e XL |
205 | tcx.generics_of(tcx.parent(def_id).unwrap()) |
206 | } | |
cdc7bbd5 XL |
207 | // Other `DefKind`s don't have generics and would ICE when calling |
208 | // `generics_of`. | |
209 | Res::Def( | |
210 | DefKind::Struct | |
211 | | DefKind::Union | |
212 | | DefKind::Enum | |
cdc7bbd5 XL |
213 | | DefKind::Trait |
214 | | DefKind::OpaqueTy | |
215 | | DefKind::TyAlias | |
216 | | DefKind::ForeignTy | |
217 | | DefKind::TraitAlias | |
218 | | DefKind::AssocTy | |
219 | | DefKind::Fn | |
220 | | DefKind::AssocFn | |
221 | | DefKind::AssocConst | |
222 | | DefKind::Impl, | |
223 | def_id, | |
224 | ) => tcx.generics_of(def_id), | |
3dfed10e XL |
225 | Res::Err => { |
226 | tcx.sess.delay_span_bug(tcx.def_span(def_id), "anon const with Res::Err"); | |
227 | return None; | |
228 | } | |
29967ef6 XL |
229 | _ => { |
230 | // If the user tries to specify generics on a type that does not take them, | |
231 | // e.g. `usize<T>`, we may hit this branch, in which case we treat it as if | |
232 | // no arguments have been passed. An error should already have been emitted. | |
233 | tcx.sess.delay_span_bug( | |
234 | tcx.def_span(def_id), | |
235 | &format!("unexpected anon const res {:?} in path: {:?}", res, path), | |
236 | ); | |
237 | return None; | |
238 | } | |
3dfed10e XL |
239 | }; |
240 | ||
241 | generics | |
242 | .params | |
243 | .iter() | |
cdc7bbd5 | 244 | .filter(|param| matches!(param.kind, ty::GenericParamDefKind::Const { .. })) |
3dfed10e XL |
245 | .nth(arg_index) |
246 | .map(|param| param.def_id) | |
247 | } | |
248 | _ => None, | |
249 | } | |
250 | } else { | |
251 | None | |
252 | } | |
253 | } | |
254 | ||
5869c6ff XL |
255 | fn get_path_containing_arg_in_pat<'hir>( |
256 | pat: &'hir hir::Pat<'hir>, | |
257 | arg_id: HirId, | |
258 | ) -> Option<&'hir hir::Path<'hir>> { | |
259 | use hir::*; | |
260 | ||
261 | let is_arg_in_path = |p: &hir::Path<'_>| { | |
262 | p.segments | |
263 | .iter() | |
264 | .filter_map(|seg| seg.args) | |
265 | .flat_map(|args| args.args) | |
266 | .any(|arg| arg.id() == arg_id) | |
267 | }; | |
268 | let mut arg_path = None; | |
269 | pat.walk(|pat| match pat.kind { | |
270 | PatKind::Struct(QPath::Resolved(_, path), _, _) | |
271 | | PatKind::TupleStruct(QPath::Resolved(_, path), _, _) | |
272 | | PatKind::Path(QPath::Resolved(_, path)) | |
273 | if is_arg_in_path(path) => | |
274 | { | |
275 | arg_path = Some(path); | |
276 | false | |
277 | } | |
278 | _ => true, | |
279 | }); | |
280 | arg_path | |
281 | } | |
282 | ||
94222f64 XL |
283 | pub(super) fn default_anon_const_substs(tcx: TyCtxt<'_>, def_id: DefId) -> SubstsRef<'_> { |
284 | let generics = tcx.generics_of(def_id); | |
285 | if let Some(parent) = generics.parent { | |
286 | // This is the reason we bother with having optional anon const substs. | |
287 | // | |
288 | // In the future the substs of an anon const will depend on its parents predicates | |
289 | // at which point eagerly looking at them will cause a query cycle. | |
290 | // | |
291 | // So for now this is only an assurance that this approach won't cause cycle errors in | |
292 | // the future. | |
293 | let _cycle_check = tcx.predicates_of(parent); | |
294 | } | |
295 | ||
296 | let substs = InternalSubsts::identity_for_item(tcx, def_id); | |
297 | // We only expect substs with the following type flags as default substs. | |
298 | // | |
299 | // Getting this wrong can lead to ICE and unsoundness, so we assert it here. | |
300 | for arg in substs.iter() { | |
301 | let allowed_flags = ty::TypeFlags::MAY_NEED_DEFAULT_CONST_SUBSTS | |
3c0e092e XL |
302 | | ty::TypeFlags::STILL_FURTHER_SPECIALIZABLE |
303 | | ty::TypeFlags::HAS_ERROR; | |
94222f64 XL |
304 | assert!(!arg.has_type_flags(!allowed_flags)); |
305 | } | |
306 | substs | |
307 | } | |
308 | ||
74b04a01 | 309 | pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { |
3dfed10e | 310 | let def_id = def_id.expect_local(); |
74b04a01 XL |
311 | use rustc_hir::*; |
312 | ||
3dfed10e | 313 | let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); |
74b04a01 | 314 | |
3dfed10e | 315 | let icx = ItemCtxt::new(tcx, def_id.to_def_id()); |
74b04a01 XL |
316 | |
317 | match tcx.hir().get(hir_id) { | |
318 | Node::TraitItem(item) => match item.kind { | |
ba9703b0 | 319 | TraitItemKind::Fn(..) => { |
3dfed10e XL |
320 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
321 | tcx.mk_fn_def(def_id.to_def_id(), substs) | |
74b04a01 | 322 | } |
c295e0f8 | 323 | TraitItemKind::Const(ty, body_id) => body_id |
74b04a01 XL |
324 | .and_then(|body_id| { |
325 | if is_suggestable_infer_ty(ty) { | |
136023e0 XL |
326 | Some(infer_placeholder_type( |
327 | tcx, def_id, body_id, ty.span, item.ident, "constant", | |
328 | )) | |
74b04a01 XL |
329 | } else { |
330 | None | |
331 | } | |
332 | }) | |
333 | .unwrap_or_else(|| icx.to_ty(ty)), | |
c295e0f8 | 334 | TraitItemKind::Type(_, Some(ty)) => icx.to_ty(ty), |
74b04a01 XL |
335 | TraitItemKind::Type(_, None) => { |
336 | span_bug!(item.span, "associated type missing default"); | |
337 | } | |
338 | }, | |
339 | ||
340 | Node::ImplItem(item) => match item.kind { | |
ba9703b0 | 341 | ImplItemKind::Fn(..) => { |
3dfed10e XL |
342 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
343 | tcx.mk_fn_def(def_id.to_def_id(), substs) | |
74b04a01 | 344 | } |
c295e0f8 | 345 | ImplItemKind::Const(ty, body_id) => { |
74b04a01 | 346 | if is_suggestable_infer_ty(ty) { |
136023e0 | 347 | infer_placeholder_type(tcx, def_id, body_id, ty.span, item.ident, "constant") |
74b04a01 XL |
348 | } else { |
349 | icx.to_ty(ty) | |
350 | } | |
351 | } | |
c295e0f8 | 352 | ImplItemKind::TyAlias(ty) => { |
ba9703b0 | 353 | if tcx.impl_trait_ref(tcx.hir().get_parent_did(hir_id).to_def_id()).is_none() { |
6a06907d | 354 | check_feature_inherent_assoc_ty(tcx, item.span); |
74b04a01 XL |
355 | } |
356 | ||
357 | icx.to_ty(ty) | |
358 | } | |
359 | }, | |
360 | ||
361 | Node::Item(item) => { | |
362 | match item.kind { | |
c295e0f8 | 363 | ItemKind::Static(ty, .., body_id) => { |
74b04a01 | 364 | if is_suggestable_infer_ty(ty) { |
136023e0 XL |
365 | infer_placeholder_type( |
366 | tcx, | |
367 | def_id, | |
368 | body_id, | |
369 | ty.span, | |
370 | item.ident, | |
371 | "static variable", | |
372 | ) | |
373 | } else { | |
374 | icx.to_ty(ty) | |
375 | } | |
376 | } | |
c295e0f8 | 377 | ItemKind::Const(ty, body_id) => { |
136023e0 XL |
378 | if is_suggestable_infer_ty(ty) { |
379 | infer_placeholder_type( | |
380 | tcx, def_id, body_id, ty.span, item.ident, "constant", | |
381 | ) | |
74b04a01 XL |
382 | } else { |
383 | icx.to_ty(ty) | |
384 | } | |
385 | } | |
c295e0f8 XL |
386 | ItemKind::TyAlias(self_ty, _) |
387 | | ItemKind::Impl(hir::Impl { self_ty, .. }) => icx.to_ty(self_ty), | |
74b04a01 | 388 | ItemKind::Fn(..) => { |
3dfed10e XL |
389 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
390 | tcx.mk_fn_def(def_id.to_def_id(), substs) | |
74b04a01 XL |
391 | } |
392 | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) => { | |
393 | let def = tcx.adt_def(def_id); | |
3dfed10e | 394 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
74b04a01 XL |
395 | tcx.mk_adt(def, substs) |
396 | } | |
a2a8927a | 397 | ItemKind::OpaqueTy(OpaqueTy { origin: hir::OpaqueTyOrigin::TyAlias, .. }) => { |
3dfed10e | 398 | find_opaque_ty_constraints(tcx, def_id) |
74b04a01 XL |
399 | } |
400 | // Opaque types desugared from `impl Trait`. | |
a2a8927a | 401 | ItemKind::OpaqueTy(OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn(owner) | hir::OpaqueTyOrigin::AsyncFn(owner), .. }) => { |
f035d41b | 402 | let concrete_ty = tcx |
a2a8927a | 403 | .mir_borrowck(owner) |
f035d41b | 404 | .concrete_opaque_types |
136023e0 | 405 | .get_value_matching(|(key, _)| key.def_id == def_id.to_def_id()) |
c295e0f8 | 406 | .copied() |
74b04a01 XL |
407 | .unwrap_or_else(|| { |
408 | tcx.sess.delay_span_bug( | |
409 | DUMMY_SP, | |
410 | &format!( | |
3dfed10e | 411 | "owner {:?} has no opaque type for {:?} in its typeck results", |
74b04a01 XL |
412 | owner, def_id, |
413 | ), | |
414 | ); | |
ba9703b0 | 415 | if let Some(ErrorReported) = |
a2a8927a | 416 | tcx.typeck(owner).tainted_by_errors |
ba9703b0 | 417 | { |
74b04a01 XL |
418 | // Some error in the |
419 | // owner fn prevented us from populating | |
420 | // the `concrete_opaque_types` table. | |
f035d41b | 421 | tcx.ty_error() |
74b04a01 XL |
422 | } else { |
423 | // We failed to resolve the opaque type or it | |
424 | // resolves to itself. Return the non-revealed | |
425 | // type, which should result in E0720. | |
426 | tcx.mk_opaque( | |
3dfed10e XL |
427 | def_id.to_def_id(), |
428 | InternalSubsts::identity_for_item(tcx, def_id.to_def_id()), | |
74b04a01 XL |
429 | ) |
430 | } | |
431 | }); | |
432 | debug!("concrete_ty = {:?}", concrete_ty); | |
74b04a01 XL |
433 | concrete_ty |
434 | } | |
435 | ItemKind::Trait(..) | |
436 | | ItemKind::TraitAlias(..) | |
94222f64 | 437 | | ItemKind::Macro(..) |
74b04a01 | 438 | | ItemKind::Mod(..) |
fc512014 | 439 | | ItemKind::ForeignMod { .. } |
74b04a01 XL |
440 | | ItemKind::GlobalAsm(..) |
441 | | ItemKind::ExternCrate(..) | |
442 | | ItemKind::Use(..) => { | |
443 | span_bug!( | |
444 | item.span, | |
445 | "compute_type_of_item: unexpected item type: {:?}", | |
446 | item.kind | |
447 | ); | |
448 | } | |
449 | } | |
450 | } | |
451 | ||
452 | Node::ForeignItem(foreign_item) => match foreign_item.kind { | |
453 | ForeignItemKind::Fn(..) => { | |
3dfed10e XL |
454 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
455 | tcx.mk_fn_def(def_id.to_def_id(), substs) | |
74b04a01 | 456 | } |
c295e0f8 | 457 | ForeignItemKind::Static(t, _) => icx.to_ty(t), |
3dfed10e | 458 | ForeignItemKind::Type => tcx.mk_foreign(def_id.to_def_id()), |
74b04a01 XL |
459 | }, |
460 | ||
461 | Node::Ctor(&ref def) | Node::Variant(Variant { data: ref def, .. }) => match *def { | |
462 | VariantData::Unit(..) | VariantData::Struct(..) => { | |
ba9703b0 | 463 | tcx.type_of(tcx.hir().get_parent_did(hir_id).to_def_id()) |
74b04a01 XL |
464 | } |
465 | VariantData::Tuple(..) => { | |
3dfed10e XL |
466 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
467 | tcx.mk_fn_def(def_id.to_def_id(), substs) | |
74b04a01 XL |
468 | } |
469 | }, | |
470 | ||
c295e0f8 | 471 | Node::Field(field) => icx.to_ty(field.ty), |
74b04a01 | 472 | |
a2a8927a | 473 | Node::Expr(&Expr { kind: ExprKind::Closure(..), .. }) => tcx.typeck(def_id).node_type(hir_id), |
74b04a01 | 474 | |
94222f64 XL |
475 | Node::AnonConst(_) if let Some(param) = tcx.opt_const_param_of(def_id) => { |
476 | // We defer to `type_of` of the corresponding parameter | |
477 | // for generic arguments. | |
478 | tcx.type_of(param) | |
479 | } | |
3dfed10e | 480 | |
94222f64 | 481 | Node::AnonConst(_) => { |
74b04a01 XL |
482 | let parent_node = tcx.hir().get(tcx.hir().get_parent_node(hir_id)); |
483 | match parent_node { | |
484 | Node::Ty(&Ty { kind: TyKind::Array(_, ref constant), .. }) | |
74b04a01 | 485 | | Node::Expr(&Expr { kind: ExprKind::Repeat(_, ref constant), .. }) |
a2a8927a | 486 | if constant.hir_id() == hir_id => |
74b04a01 XL |
487 | { |
488 | tcx.types.usize | |
489 | } | |
cdc7bbd5 XL |
490 | Node::Ty(&Ty { kind: TyKind::Typeof(ref e), .. }) if e.hir_id == hir_id => { |
491 | tcx.typeck(def_id).node_type(e.hir_id) | |
492 | } | |
74b04a01 | 493 | |
29967ef6 XL |
494 | Node::Expr(&Expr { kind: ExprKind::ConstBlock(ref anon_const), .. }) |
495 | if anon_const.hir_id == hir_id => | |
496 | { | |
3c0e092e XL |
497 | let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); |
498 | substs.as_inline_const().ty() | |
29967ef6 XL |
499 | } |
500 | ||
17df50a5 XL |
501 | Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. }) |
502 | | Node::Item(&Item { kind: ItemKind::GlobalAsm(asm), .. }) | |
503 | if asm.operands.iter().any(|(op, _op_sp)| match op { | |
cdc7bbd5 XL |
504 | hir::InlineAsmOperand::Const { anon_const } => anon_const.hir_id == hir_id, |
505 | _ => false, | |
506 | }) => | |
507 | { | |
508 | tcx.typeck(def_id).node_type(hir_id) | |
509 | } | |
510 | ||
ba9703b0 XL |
511 | Node::Variant(Variant { disr_expr: Some(ref e), .. }) if e.hir_id == hir_id => tcx |
512 | .adt_def(tcx.hir().get_parent_did(hir_id).to_def_id()) | |
513 | .repr | |
514 | .discr_type() | |
515 | .to_ty(tcx), | |
74b04a01 | 516 | |
cdc7bbd5 XL |
517 | Node::GenericParam(&GenericParam { |
518 | hir_id: param_hir_id, | |
519 | kind: GenericParamKind::Const { default: Some(ct), .. }, | |
520 | .. | |
521 | }) if ct.hir_id == hir_id => tcx.type_of(tcx.hir().local_def_id(param_hir_id)), | |
522 | ||
f035d41b XL |
523 | x => tcx.ty_error_with_message( |
524 | DUMMY_SP, | |
136023e0 | 525 | &format!("unexpected const parent in type_of(): {:?}", x), |
f035d41b | 526 | ), |
74b04a01 XL |
527 | } |
528 | } | |
529 | ||
530 | Node::GenericParam(param) => match ¶m.kind { | |
3dfed10e XL |
531 | GenericParamKind::Type { default: Some(ty), .. } |
532 | | GenericParamKind::Const { ty, .. } => icx.to_ty(ty), | |
74b04a01 XL |
533 | x => bug!("unexpected non-type Node::GenericParam: {:?}", x), |
534 | }, | |
535 | ||
536 | x => { | |
136023e0 | 537 | bug!("unexpected sort of node in type_of(): {:?}", x); |
74b04a01 XL |
538 | } |
539 | } | |
540 | } | |
541 | ||
136023e0 | 542 | #[instrument(skip(tcx), level = "debug")] |
c295e0f8 XL |
543 | /// Checks "defining uses" of opaque `impl Trait` types to ensure that they meet the restrictions |
544 | /// laid for "higher-order pattern unification". | |
545 | /// This ensures that inference is tractable. | |
546 | /// In particular, definitions of opaque types can only use other generics as arguments, | |
547 | /// and they cannot repeat an argument. Example: | |
548 | /// | |
549 | /// ```rust | |
550 | /// type Foo<A, B> = impl Bar<A, B>; | |
551 | /// | |
552 | /// // Okay -- `Foo` is applied to two distinct, generic types. | |
553 | /// fn a<T, U>() -> Foo<T, U> { .. } | |
554 | /// | |
555 | /// // Not okay -- `Foo` is applied to `T` twice. | |
556 | /// fn b<T>() -> Foo<T, T> { .. } | |
557 | /// | |
558 | /// // Not okay -- `Foo` is applied to a non-generic type. | |
559 | /// fn b<T>() -> Foo<T, u32> { .. } | |
560 | /// ``` | |
561 | /// | |
f9f354fc | 562 | fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { |
74b04a01 XL |
563 | use rustc_hir::{Expr, ImplItem, Item, TraitItem}; |
564 | ||
74b04a01 XL |
565 | struct ConstraintLocator<'tcx> { |
566 | tcx: TyCtxt<'tcx>, | |
136023e0 XL |
567 | |
568 | /// def_id of the opaque type whose defining uses are being checked | |
74b04a01 | 569 | def_id: DefId, |
136023e0 XL |
570 | |
571 | /// as we walk the defining uses, we are checking that all of them | |
572 | /// define the same hidden type. This variable is set to `Some` | |
573 | /// with the first type that we find, and then later types are | |
574 | /// checked against it (we also carry the span of that first | |
575 | /// type). | |
ba9703b0 | 576 | found: Option<(Span, Ty<'tcx>)>, |
74b04a01 XL |
577 | } |
578 | ||
579 | impl ConstraintLocator<'_> { | |
136023e0 | 580 | #[instrument(skip(self), level = "debug")] |
f9f354fc | 581 | fn check(&mut self, def_id: LocalDefId) { |
74b04a01 | 582 | // Don't try to check items that cannot possibly constrain the type. |
3dfed10e | 583 | if !self.tcx.has_typeck_results(def_id) { |
136023e0 | 584 | debug!("no constraint: no typeck results"); |
74b04a01 XL |
585 | return; |
586 | } | |
587 | // Calling `mir_borrowck` can lead to cycle errors through | |
588 | // const-checking, avoid calling it if we don't have to. | |
94222f64 | 589 | if !self.tcx.typeck(def_id).concrete_opaque_types.contains(&self.def_id) { |
136023e0 | 590 | debug!("no constraints in typeck results"); |
74b04a01 XL |
591 | return; |
592 | } | |
593 | // Use borrowck to get the type with unerased regions. | |
17df50a5 | 594 | let concrete_opaque_types = &self.tcx.mir_borrowck(def_id).concrete_opaque_types; |
136023e0 XL |
595 | debug!(?concrete_opaque_types); |
596 | for (opaque_type_key, concrete_type) in concrete_opaque_types { | |
597 | if opaque_type_key.def_id != self.def_id { | |
598 | // Ignore constraints for other opaque types. | |
599 | continue; | |
600 | } | |
601 | ||
602 | debug!(?concrete_type, ?opaque_type_key.substs, "found constraint"); | |
74b04a01 XL |
603 | |
604 | // FIXME(oli-obk): trace the actual span from inference to improve errors. | |
605 | let span = self.tcx.def_span(def_id); | |
ba9703b0 | 606 | |
ba9703b0 | 607 | if let Some((prev_span, prev_ty)) = self.found { |
c295e0f8 | 608 | if *concrete_type != prev_ty && !(*concrete_type, prev_ty).references_error() { |
136023e0 | 609 | debug!(?span); |
74b04a01 XL |
610 | // Found different concrete types for the opaque type. |
611 | let mut err = self.tcx.sess.struct_span_err( | |
612 | span, | |
613 | "concrete type differs from previous defining opaque type use", | |
614 | ); | |
615 | err.span_label( | |
616 | span, | |
617 | format!("expected `{}`, got `{}`", prev_ty, concrete_type), | |
618 | ); | |
619 | err.span_note(prev_span, "previous use here"); | |
620 | err.emit(); | |
74b04a01 XL |
621 | } |
622 | } else { | |
ba9703b0 | 623 | self.found = Some((span, concrete_type)); |
74b04a01 | 624 | } |
74b04a01 XL |
625 | } |
626 | } | |
627 | } | |
628 | ||
629 | impl<'tcx> intravisit::Visitor<'tcx> for ConstraintLocator<'tcx> { | |
630 | type Map = Map<'tcx>; | |
631 | ||
ba9703b0 XL |
632 | fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> { |
633 | intravisit::NestedVisitorMap::All(self.tcx.hir()) | |
74b04a01 XL |
634 | } |
635 | fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) { | |
636 | if let hir::ExprKind::Closure(..) = ex.kind { | |
637 | let def_id = self.tcx.hir().local_def_id(ex.hir_id); | |
638 | self.check(def_id); | |
639 | } | |
640 | intravisit::walk_expr(self, ex); | |
641 | } | |
642 | fn visit_item(&mut self, it: &'tcx Item<'tcx>) { | |
643 | debug!("find_existential_constraints: visiting {:?}", it); | |
74b04a01 | 644 | // The opaque type itself or its children are not within its reveal scope. |
6a06907d XL |
645 | if it.def_id.to_def_id() != self.def_id { |
646 | self.check(it.def_id); | |
74b04a01 XL |
647 | intravisit::walk_item(self, it); |
648 | } | |
649 | } | |
650 | fn visit_impl_item(&mut self, it: &'tcx ImplItem<'tcx>) { | |
651 | debug!("find_existential_constraints: visiting {:?}", it); | |
74b04a01 | 652 | // The opaque type itself or its children are not within its reveal scope. |
6a06907d XL |
653 | if it.def_id.to_def_id() != self.def_id { |
654 | self.check(it.def_id); | |
74b04a01 XL |
655 | intravisit::walk_impl_item(self, it); |
656 | } | |
657 | } | |
658 | fn visit_trait_item(&mut self, it: &'tcx TraitItem<'tcx>) { | |
659 | debug!("find_existential_constraints: visiting {:?}", it); | |
6a06907d | 660 | self.check(it.def_id); |
74b04a01 XL |
661 | intravisit::walk_trait_item(self, it); |
662 | } | |
663 | } | |
664 | ||
3dfed10e | 665 | let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); |
74b04a01 | 666 | let scope = tcx.hir().get_defining_scope(hir_id); |
f9f354fc | 667 | let mut locator = ConstraintLocator { def_id: def_id.to_def_id(), tcx, found: None }; |
74b04a01 XL |
668 | |
669 | debug!("find_opaque_ty_constraints: scope={:?}", scope); | |
670 | ||
671 | if scope == hir::CRATE_HIR_ID { | |
c295e0f8 | 672 | tcx.hir().walk_toplevel_module(&mut locator); |
74b04a01 XL |
673 | } else { |
674 | debug!("find_opaque_ty_constraints: scope={:?}", tcx.hir().get(scope)); | |
675 | match tcx.hir().get(scope) { | |
676 | // We explicitly call `visit_*` methods, instead of using `intravisit::walk_*` methods | |
677 | // This allows our visitor to process the defining item itself, causing | |
678 | // it to pick up any 'sibling' defining uses. | |
679 | // | |
680 | // For example, this code: | |
681 | // ``` | |
682 | // fn foo() { | |
683 | // type Blah = impl Debug; | |
684 | // let my_closure = || -> Blah { true }; | |
685 | // } | |
686 | // ``` | |
687 | // | |
688 | // requires us to explicitly process `foo()` in order | |
689 | // to notice the defining usage of `Blah`. | |
c295e0f8 XL |
690 | Node::Item(it) => locator.visit_item(it), |
691 | Node::ImplItem(it) => locator.visit_impl_item(it), | |
692 | Node::TraitItem(it) => locator.visit_trait_item(it), | |
74b04a01 XL |
693 | other => bug!("{:?} is not a valid scope for an opaque type item", other), |
694 | } | |
695 | } | |
696 | ||
697 | match locator.found { | |
ba9703b0 | 698 | Some((_, ty)) => ty, |
74b04a01 XL |
699 | None => { |
700 | let span = tcx.def_span(def_id); | |
701 | tcx.sess.span_err(span, "could not find defining uses"); | |
f035d41b | 702 | tcx.ty_error() |
74b04a01 XL |
703 | } |
704 | } | |
705 | } | |
706 | ||
136023e0 XL |
707 | fn infer_placeholder_type<'a>( |
708 | tcx: TyCtxt<'a>, | |
f9f354fc | 709 | def_id: LocalDefId, |
74b04a01 XL |
710 | body_id: hir::BodyId, |
711 | span: Span, | |
712 | item_ident: Ident, | |
136023e0 XL |
713 | kind: &'static str, |
714 | ) -> Ty<'a> { | |
715 | // Attempts to make the type nameable by turning FnDefs into FnPtrs. | |
716 | struct MakeNameable<'tcx> { | |
717 | success: bool, | |
718 | tcx: TyCtxt<'tcx>, | |
719 | } | |
720 | ||
721 | impl<'tcx> MakeNameable<'tcx> { | |
722 | fn new(tcx: TyCtxt<'tcx>) -> Self { | |
723 | MakeNameable { success: true, tcx } | |
724 | } | |
725 | } | |
726 | ||
a2a8927a | 727 | impl<'tcx> TypeFolder<'tcx> for MakeNameable<'tcx> { |
136023e0 XL |
728 | fn tcx(&self) -> TyCtxt<'tcx> { |
729 | self.tcx | |
730 | } | |
731 | ||
732 | fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { | |
733 | if !self.success { | |
734 | return ty; | |
735 | } | |
736 | ||
737 | match ty.kind() { | |
738 | ty::FnDef(def_id, _) => self.tcx.mk_fn_ptr(self.tcx.fn_sig(*def_id)), | |
739 | // FIXME: non-capturing closures should also suggest a function pointer | |
740 | ty::Closure(..) | ty::Generator(..) => { | |
741 | self.success = false; | |
742 | ty | |
743 | } | |
744 | _ => ty.super_fold_with(self), | |
745 | } | |
746 | } | |
747 | } | |
748 | ||
3dfed10e | 749 | let ty = tcx.diagnostic_only_typeck(def_id).node_type(body_id.hir_id); |
74b04a01 XL |
750 | |
751 | // If this came from a free `const` or `static mut?` item, | |
752 | // then the user may have written e.g. `const A = 42;`. | |
753 | // In this case, the parser has stashed a diagnostic for | |
754 | // us to improve in typeck so we do that now. | |
755 | match tcx.sess.diagnostic().steal_diagnostic(span, StashKey::ItemNoType) { | |
756 | Some(mut err) => { | |
dc3f5686 XL |
757 | if !ty.references_error() { |
758 | // The parser provided a sub-optimal `HasPlaceholders` suggestion for the type. | |
759 | // We are typeck and have the real type, so remove that and suggest the actual type. | |
760 | err.suggestions.clear(); | |
761 | ||
762 | // Suggesting unnameable types won't help. | |
763 | let mut mk_nameable = MakeNameable::new(tcx); | |
764 | let ty = mk_nameable.fold_ty(ty); | |
765 | let sugg_ty = if mk_nameable.success { Some(ty) } else { None }; | |
766 | if let Some(sugg_ty) = sugg_ty { | |
767 | err.span_suggestion( | |
768 | span, | |
769 | &format!("provide a type for the {item}", item = kind), | |
770 | format!("{}: {}", item_ident, sugg_ty), | |
771 | Applicability::MachineApplicable, | |
772 | ); | |
773 | } else { | |
774 | err.span_note( | |
775 | tcx.hir().body(body_id).value.span, | |
3c0e092e | 776 | &format!("however, the inferred type `{}` cannot be named", ty), |
dc3f5686 XL |
777 | ); |
778 | } | |
136023e0 XL |
779 | } |
780 | ||
dc3f5686 | 781 | err.emit(); |
74b04a01 XL |
782 | } |
783 | None => { | |
a2a8927a | 784 | let mut diag = bad_placeholder(tcx, "type", vec![span], kind); |
6a06907d XL |
785 | |
786 | if !ty.references_error() { | |
136023e0 XL |
787 | let mut mk_nameable = MakeNameable::new(tcx); |
788 | let ty = mk_nameable.fold_ty(ty); | |
789 | let sugg_ty = if mk_nameable.success { Some(ty) } else { None }; | |
790 | if let Some(sugg_ty) = sugg_ty { | |
791 | diag.span_suggestion( | |
792 | span, | |
793 | "replace with the correct type", | |
794 | sugg_ty.to_string(), | |
795 | Applicability::MaybeIncorrect, | |
796 | ); | |
797 | } else { | |
798 | diag.span_note( | |
799 | tcx.hir().body(body_id).value.span, | |
3c0e092e | 800 | &format!("however, the inferred type `{}` cannot be named", ty), |
136023e0 XL |
801 | ); |
802 | } | |
74b04a01 | 803 | } |
6a06907d | 804 | |
74b04a01 XL |
805 | diag.emit(); |
806 | } | |
807 | } | |
808 | ||
ba9703b0 | 809 | // Typeck doesn't expect erased regions to be returned from `type_of`. |
fc512014 | 810 | tcx.fold_regions(ty, &mut false, |r, _| match r { |
ba9703b0 XL |
811 | ty::ReErased => tcx.lifetimes.re_static, |
812 | _ => r, | |
813 | }) | |
74b04a01 XL |
814 | } |
815 | ||
6a06907d XL |
816 | fn check_feature_inherent_assoc_ty(tcx: TyCtxt<'_>, span: Span) { |
817 | if !tcx.features().inherent_associated_types { | |
818 | use rustc_session::parse::feature_err; | |
819 | use rustc_span::symbol::sym; | |
820 | feature_err( | |
821 | &tcx.sess.parse_sess, | |
822 | sym::inherent_associated_types, | |
823 | span, | |
824 | "inherent associated types are unstable", | |
825 | ) | |
826 | .emit(); | |
827 | } | |
74b04a01 | 828 | } |