1#![allow(rustc::diagnostic_outside_of_impl)]
3#![allow(rustc::untranslatable_diagnostic)]
4#![feature(assert_matches)]
5#![feature(box_patterns)]
6#![feature(if_let_guard)]
7#![feature(iter_intersperse)]
8#![feature(never_type)]
9mod _match;
12mod autoderef;
13mod callee;
14pub mod cast;
16mod check;
17mod closure;
18mod coercion;
19mod demand;
20mod diverges;
21mod errors;
22mod expectation;
23mod expr;
24mod inline_asm;
25pub mod expr_use_visitor;
27mod fallback;
28mod fn_ctxt;
29mod gather_locals;
30mod intrinsicck;
31mod loops;
32mod method;
33mod naked_functions;
34mod op;
35mod opaque_types;
36mod pat;
37mod place_op;
38mod rvalue_scopes;
39mod typeck_root_ctxt;
40mod upvar;
41mod writeback;
42
43pub use coercion::can_coerce;
44use fn_ctxt::FnCtxt;
45use rustc_attr_data_structures::{AttributeKind, find_attr};
46use rustc_data_structures::unord::UnordSet;
47use rustc_errors::codes::*;
48use rustc_errors::{Applicability, ErrorGuaranteed, pluralize, struct_span_code_err};
49use rustc_hir as hir;
50use rustc_hir::def::{DefKind, Res};
51use rustc_hir::{HirId, HirIdMap, Node};
52use rustc_hir_analysis::check::{check_abi, check_custom_abi};
53use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
54use rustc_infer::traits::{ObligationCauseCode, ObligationInspector, WellFormedLoc};
55use rustc_middle::query::Providers;
56use rustc_middle::ty::{self, Ty, TyCtxt};
57use rustc_middle::{bug, span_bug};
58use rustc_session::config;
59use rustc_span::Span;
60use rustc_span::def_id::LocalDefId;
61use tracing::{debug, instrument};
62use typeck_root_ctxt::TypeckRootCtxt;
63
64use crate::check::check_fn;
65use crate::coercion::DynamicCoerceMany;
66use crate::diverges::Diverges;
67use crate::expectation::Expectation;
68use crate::fn_ctxt::LoweredTy;
69use crate::gather_locals::GatherLocalsVisitor;
70
71rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
72
73#[macro_export]
74macro_rules! type_error_struct {
75 ($dcx:expr, $span:expr, $typ:expr, $code:expr, $($message:tt)*) => ({
76 let mut err = rustc_errors::struct_span_code_err!($dcx, $span, $code, $($message)*);
77
78 if $typ.references_error() {
79 err.downgrade_to_delayed_bug();
80 }
81
82 err
83 })
84}
85
86fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDefId> {
87 &tcx.typeck(def_id).used_trait_imports
88}
89
90fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
91 typeck_with_inspect(tcx, def_id, None)
92}
93
94pub fn inspect_typeck<'tcx>(
99 tcx: TyCtxt<'tcx>,
100 def_id: LocalDefId,
101 inspect: ObligationInspector<'tcx>,
102) -> &'tcx ty::TypeckResults<'tcx> {
103 typeck_with_inspect(tcx, def_id, Some(inspect))
104}
105
106#[instrument(level = "debug", skip(tcx, inspector), ret)]
107fn typeck_with_inspect<'tcx>(
108 tcx: TyCtxt<'tcx>,
109 def_id: LocalDefId,
110 inspector: Option<ObligationInspector<'tcx>>,
111) -> &'tcx ty::TypeckResults<'tcx> {
112 let typeck_root_def_id = tcx.typeck_root_def_id(def_id.to_def_id()).expect_local();
115 if typeck_root_def_id != def_id {
116 return tcx.typeck(typeck_root_def_id);
117 }
118
119 let id = tcx.local_def_id_to_hir_id(def_id);
120 let node = tcx.hir_node(id);
121 let span = tcx.def_span(def_id);
122
123 let body_id = node.body_id().unwrap_or_else(|| {
125 span_bug!(span, "can't type-check body of {:?}", def_id);
126 });
127 let body = tcx.hir_body(body_id);
128
129 let param_env = tcx.param_env(def_id);
130
131 let root_ctxt = TypeckRootCtxt::new(tcx, def_id);
132 if let Some(inspector) = inspector {
133 root_ctxt.infcx.attach_obligation_inspector(inspector);
134 }
135 let mut fcx = FnCtxt::new(&root_ctxt, param_env, def_id);
136
137 if let hir::Node::Item(hir::Item { kind: hir::ItemKind::GlobalAsm { .. }, .. }) = node {
138 let ty = fcx.check_expr(body.value);
141 fcx.write_ty(id, ty);
142 } else if let Some(hir::FnSig { header, decl, span: fn_sig_span }) = node.fn_sig() {
143 let fn_sig = if decl.output.is_suggestable_infer_ty().is_some() {
144 fcx.lowerer().lower_fn_ty(id, header.safety(), header.abi, decl, None, None)
149 } else {
150 tcx.fn_sig(def_id).instantiate_identity()
151 };
152
153 check_abi(tcx, id, span, fn_sig.abi());
154 check_custom_abi(tcx, def_id, fn_sig.skip_binder(), *fn_sig_span);
155
156 loops::check(tcx, def_id, body);
157
158 let mut fn_sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), fn_sig);
160
161 let arg_span =
167 |idx| decl.inputs.get(idx).map_or(decl.output.span(), |arg: &hir::Ty<'_>| arg.span);
168
169 fn_sig.inputs_and_output = tcx.mk_type_list_from_iter(
170 fn_sig
171 .inputs_and_output
172 .iter()
173 .enumerate()
174 .map(|(idx, ty)| fcx.normalize(arg_span(idx), ty)),
175 );
176
177 if find_attr!(tcx.get_all_attrs(def_id), AttributeKind::Naked(..)) {
178 naked_functions::typeck_naked_fn(tcx, def_id, body);
179 }
180
181 check_fn(&mut fcx, fn_sig, None, decl, def_id, body, tcx.features().unsized_fn_params());
182 } else {
183 let expected_type = if let Some(infer_ty) = infer_type_if_missing(&fcx, node) {
184 infer_ty
185 } else if let Some(ty) = node.ty()
186 && ty.is_suggestable_infer_ty()
187 {
188 fcx.lowerer().lower_ty(ty)
193 } else {
194 tcx.type_of(def_id).instantiate_identity()
195 };
196
197 loops::check(tcx, def_id, body);
198
199 let expected_type = fcx.normalize(body.value.span, expected_type);
200
201 let wf_code = ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(def_id)));
202 fcx.register_wf_obligation(expected_type.into(), body.value.span, wf_code);
203
204 fcx.check_expr_coercible_to_type(body.value, expected_type, None);
205
206 fcx.write_ty(id, expected_type);
207 };
208
209 fcx.check_repeat_exprs();
220
221 fcx.type_inference_fallback();
222
223 fcx.check_casts();
226 fcx.select_obligations_where_possible(|_| {});
227
228 fcx.closure_analyze(body);
231 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
232 fcx.resolve_rvalue_scopes(def_id.to_def_id());
235
236 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
237 let ty = fcx.normalize(span, ty);
238 fcx.require_type_is_sized(ty, span, code);
239 }
240
241 fcx.select_obligations_where_possible(|_| {});
242
243 debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
244
245 fcx.resolve_coroutine_interiors();
247
248 debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
249
250 if let None = fcx.infcx.tainted_by_errors() {
251 fcx.report_ambiguity_errors();
252 }
253
254 if let None = fcx.infcx.tainted_by_errors() {
255 fcx.check_transmutes();
256 }
257
258 fcx.check_asms();
259
260 let typeck_results = fcx.resolve_type_vars_in_body(body);
261
262 fcx.detect_opaque_types_added_during_writeback();
263
264 assert_eq!(typeck_results.hir_owner, id.owner);
267
268 typeck_results
269}
270
271fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Option<Ty<'tcx>> {
272 let tcx = fcx.tcx;
273 let def_id = fcx.body_id;
274 let expected_type = if let Some(&hir::Ty { kind: hir::TyKind::Infer(()), span, .. }) = node.ty()
275 {
276 if let Some(item) = tcx.opt_associated_item(def_id.into())
277 && let ty::AssocKind::Const { .. } = item.kind
278 && let ty::AssocItemContainer::Impl = item.container
279 && let Some(trait_item_def_id) = item.trait_item_def_id
280 {
281 let impl_def_id = item.container_id(tcx);
282 let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity();
283 let args = ty::GenericArgs::identity_for_item(tcx, def_id).rebase_onto(
284 tcx,
285 impl_def_id,
286 impl_trait_ref.args,
287 );
288 tcx.check_args_compatible(trait_item_def_id, args)
289 .then(|| tcx.type_of(trait_item_def_id).instantiate(tcx, args))
290 } else {
291 Some(fcx.next_ty_var(span))
292 }
293 } else if let Node::AnonConst(_) = node {
294 let id = tcx.local_def_id_to_hir_id(def_id);
295 match tcx.parent_hir_node(id) {
296 Node::Ty(&hir::Ty { kind: hir::TyKind::Typeof(ref anon_const), span, .. })
297 if anon_const.hir_id == id =>
298 {
299 Some(fcx.next_ty_var(span))
300 }
301 Node::Expr(&hir::Expr { kind: hir::ExprKind::InlineAsm(asm), span, .. })
302 | Node::Item(&hir::Item { kind: hir::ItemKind::GlobalAsm { asm, .. }, span, .. }) => {
303 asm.operands.iter().find_map(|(op, _op_sp)| match op {
304 hir::InlineAsmOperand::Const { anon_const } if anon_const.hir_id == id => {
305 Some(fcx.next_ty_var(span))
306 }
307 _ => None,
308 })
309 }
310 _ => None,
311 }
312 } else {
313 None
314 };
315 expected_type
316}
317
318#[derive(Debug, PartialEq, Copy, Clone)]
322struct CoroutineTypes<'tcx> {
323 resume_ty: Ty<'tcx>,
325
326 yield_ty: Ty<'tcx>,
328}
329
330#[derive(Copy, Clone, Debug, PartialEq, Eq)]
331pub enum Needs {
332 MutPlace,
333 None,
334}
335
336impl Needs {
337 fn maybe_mut_place(m: hir::Mutability) -> Self {
338 match m {
339 hir::Mutability::Mut => Needs::MutPlace,
340 hir::Mutability::Not => Needs::None,
341 }
342 }
343}
344
345#[derive(Debug, Copy, Clone)]
346pub enum PlaceOp {
347 Deref,
348 Index,
349}
350
351pub struct BreakableCtxt<'tcx> {
352 may_break: bool,
353
354 coerce: Option<DynamicCoerceMany<'tcx>>,
357}
358
359pub struct EnclosingBreakables<'tcx> {
360 stack: Vec<BreakableCtxt<'tcx>>,
361 by_id: HirIdMap<usize>,
362}
363
364impl<'tcx> EnclosingBreakables<'tcx> {
365 fn find_breakable(&mut self, target_id: HirId) -> &mut BreakableCtxt<'tcx> {
366 self.opt_find_breakable(target_id).unwrap_or_else(|| {
367 bug!("could not find enclosing breakable with id {}", target_id);
368 })
369 }
370
371 fn opt_find_breakable(&mut self, target_id: HirId) -> Option<&mut BreakableCtxt<'tcx>> {
372 match self.by_id.get(&target_id) {
373 Some(ix) => Some(&mut self.stack[*ix]),
374 None => None,
375 }
376 }
377}
378
379fn report_unexpected_variant_res(
380 tcx: TyCtxt<'_>,
381 res: Res,
382 expr: Option<&hir::Expr<'_>>,
383 qpath: &hir::QPath<'_>,
384 span: Span,
385 err_code: ErrCode,
386 expected: &str,
387) -> ErrorGuaranteed {
388 let res_descr = match res {
389 Res::Def(DefKind::Variant, _) => "struct variant",
390 _ => res.descr(),
391 };
392 let path_str = rustc_hir_pretty::qpath_to_string(&tcx, qpath);
393 let mut err = tcx
394 .dcx()
395 .struct_span_err(span, format!("expected {expected}, found {res_descr} `{path_str}`"))
396 .with_code(err_code);
397 match res {
398 Res::Def(DefKind::Fn | DefKind::AssocFn, _) if err_code == E0164 => {
399 let patterns_url = "https://doc.rust-lang.org/book/ch19-00-patterns.html";
400 err.with_span_label(span, "`fn` calls are not allowed in patterns")
401 .with_help(format!("for more information, visit {patterns_url}"))
402 }
403 Res::Def(DefKind::Variant, _) if let Some(expr) = expr => {
404 err.span_label(span, format!("not a {expected}"));
405 let variant = tcx.expect_variant_res(res);
406 let sugg = if variant.fields.is_empty() {
407 " {}".to_string()
408 } else {
409 format!(
410 " {{ {} }}",
411 variant
412 .fields
413 .iter()
414 .map(|f| format!("{}: /* value */", f.name))
415 .collect::<Vec<_>>()
416 .join(", ")
417 )
418 };
419 let descr = "you might have meant to create a new value of the struct";
420 let mut suggestion = vec![];
421 match tcx.parent_hir_node(expr.hir_id) {
422 hir::Node::Expr(hir::Expr {
423 kind: hir::ExprKind::Call(..),
424 span: call_span,
425 ..
426 }) => {
427 suggestion.push((span.shrink_to_hi().with_hi(call_span.hi()), sugg));
428 }
429 hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Binary(..), hir_id, .. }) => {
430 suggestion.push((expr.span.shrink_to_lo(), "(".to_string()));
431 if let hir::Node::Expr(drop_temps) = tcx.parent_hir_node(*hir_id)
432 && let hir::ExprKind::DropTemps(_) = drop_temps.kind
433 && let hir::Node::Expr(parent) = tcx.parent_hir_node(drop_temps.hir_id)
434 && let hir::ExprKind::If(condition, block, None) = parent.kind
435 && condition.hir_id == drop_temps.hir_id
436 && let hir::ExprKind::Block(block, _) = block.kind
437 && block.stmts.is_empty()
438 && let Some(expr) = block.expr
439 && let hir::ExprKind::Path(..) = expr.kind
440 {
441 suggestion.push((block.span.shrink_to_hi(), ")".to_string()));
446 } else {
447 suggestion.push((span.shrink_to_hi().with_hi(expr.span.hi()), sugg));
448 }
449 }
450 _ => {
451 suggestion.push((span.shrink_to_hi(), sugg));
452 }
453 }
454
455 err.multipart_suggestion_verbose(descr, suggestion, Applicability::HasPlaceholders);
456 err
457 }
458 Res::Def(DefKind::Variant, _) if expr.is_none() => {
459 err.span_label(span, format!("not a {expected}"));
460
461 let fields = &tcx.expect_variant_res(res).fields.raw;
462 let span = qpath.span().shrink_to_hi().to(span.shrink_to_hi());
463 let (msg, sugg) = if fields.is_empty() {
464 ("use the struct variant pattern syntax".to_string(), " {}".to_string())
465 } else {
466 let msg = format!(
467 "the struct variant's field{s} {are} being ignored",
468 s = pluralize!(fields.len()),
469 are = pluralize!("is", fields.len())
470 );
471 let fields = fields
472 .iter()
473 .map(|field| format!("{}: _", field.ident(tcx)))
474 .collect::<Vec<_>>()
475 .join(", ");
476 let sugg = format!(" {{ {} }}", fields);
477 (msg, sugg)
478 };
479
480 err.span_suggestion_verbose(
481 qpath.span().shrink_to_hi().to(span.shrink_to_hi()),
482 msg,
483 sugg,
484 Applicability::HasPlaceholders,
485 );
486 err
487 }
488 _ => err.with_span_label(span, format!("not a {expected}")),
489 }
490 .emit()
491}
492
493#[derive(Copy, Clone, Eq, PartialEq)]
513enum TupleArgumentsFlag {
514 DontTupleArguments,
515 TupleArguments,
516}
517
518fn fatally_break_rust(tcx: TyCtxt<'_>, span: Span) -> ! {
519 let dcx = tcx.dcx();
520 let mut diag = dcx.struct_span_bug(
521 span,
522 "It looks like you're trying to break rust; would you like some ICE?",
523 );
524 diag.note("the compiler expectedly panicked. this is a feature.");
525 diag.note(
526 "we would appreciate a joke overview: \
527 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
528 );
529 diag.note(format!("rustc {} running on {}", tcx.sess.cfg_version, config::host_tuple(),));
530 if let Some((flags, excluded_cargo_defaults)) = rustc_session::utils::extra_compiler_flags() {
531 diag.note(format!("compiler flags: {}", flags.join(" ")));
532 if excluded_cargo_defaults {
533 diag.note("some of the compiler flags provided by cargo are hidden");
534 }
535 }
536 diag.emit()
537}
538
539pub fn provide(providers: &mut Providers) {
540 method::provide(providers);
541 *providers = Providers { typeck, used_trait_imports, ..*providers };
542}