about summary refs log tree commit diff
path: root/src/librustc
diff options
context:
space:
mode:
Diffstat (limited to 'src/librustc')
-rw-r--r--src/librustc/hir/intravisit.rs7
-rw-r--r--src/librustc/hir/lowering.rs14
-rw-r--r--src/librustc/hir/lowering/expr.rs26
-rw-r--r--src/librustc/hir/mod.rs13
-rw-r--r--src/librustc/hir/print.rs21
-rw-r--r--src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs2
-rw-r--r--src/librustc/infer/error_reporting/nice_region_error/mod.rs2
-rw-r--r--src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs2
-rw-r--r--src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs29
-rw-r--r--src/librustc/lib.rs2
-rw-r--r--src/librustc/middle/expr_use_visitor.rs6
-rw-r--r--src/librustc/mir/mod.rs4
-rw-r--r--src/librustc/ty/context.rs11
-rw-r--r--src/librustc/ty/layout.rs2
-rw-r--r--src/librustc/ty/structural_impls.rs2
-rw-r--r--src/librustc/ty/sty.rs20
16 files changed, 99 insertions, 64 deletions
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
index 29e3f713276..91c19e269a7 100644
--- a/src/librustc/hir/intravisit.rs
+++ b/src/librustc/hir/intravisit.rs
@@ -1086,10 +1086,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
         ExprKind::Ret(ref optional_expression) => {
             walk_list!(visitor, visit_expr, optional_expression);
         }
-        ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
-            for expr in outputs.iter().chain(inputs.iter()) {
-                visitor.visit_expr(expr)
-            }
+        ExprKind::InlineAsm(ref asm) => {
+            walk_list!(visitor, visit_expr, &asm.outputs_exprs);
+            walk_list!(visitor, visit_expr, &asm.inputs_exprs);
         }
         ExprKind::Yield(ref subexpression, _) => {
             visitor.visit_expr(subexpression);
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 06a7a6bb301..ac8173f101a 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -2170,6 +2170,16 @@ impl<'a> LoweringContext<'a> {
         impl_trait_return_allow: bool,
         make_ret_async: Option<NodeId>,
     ) -> P<hir::FnDecl> {
+        debug!("lower_fn_decl(\
+            fn_decl: {:?}, \
+            in_band_ty_params: {:?}, \
+            impl_trait_return_allow: {}, \
+            make_ret_async: {:?})",
+            decl,
+            in_band_ty_params,
+            impl_trait_return_allow,
+            make_ret_async,
+        );
         let lt_mode = if make_ret_async.is_some() {
             // In `async fn`, argument-position elided lifetimes
             // must be transformed into fresh generic parameters so that
@@ -2462,7 +2472,7 @@ impl<'a> LoweringContext<'a> {
 
         hir::FunctionRetTy::Return(P(hir::Ty {
             kind: opaque_ty_ref,
-            span,
+            span: opaque_ty_span,
             hir_id: self.next_id(),
         }))
     }
@@ -2572,7 +2582,7 @@ impl<'a> LoweringContext<'a> {
         hir::Lifetime {
             hir_id: self.lower_node_id(id),
             span,
-            name: name,
+            name,
         }
     }
 
diff --git a/src/librustc/hir/lowering/expr.rs b/src/librustc/hir/lowering/expr.rs
index d5d3ff0db2e..929dce7aa0f 100644
--- a/src/librustc/hir/lowering/expr.rs
+++ b/src/librustc/hir/lowering/expr.rs
@@ -966,7 +966,7 @@ impl LoweringContext<'_> {
     }
 
     fn lower_expr_asm(&mut self, asm: &InlineAsm) -> hir::ExprKind {
-        let hir_asm = hir::InlineAsm {
+        let inner = hir::InlineAsmInner {
             inputs: asm.inputs.iter().map(|&(ref c, _)| c.clone()).collect(),
             outputs: asm.outputs
                 .iter()
@@ -984,18 +984,18 @@ impl LoweringContext<'_> {
             alignstack: asm.alignstack,
             dialect: asm.dialect,
         };
-
-        let outputs = asm.outputs
-            .iter()
-            .map(|out| self.lower_expr(&out.expr))
-            .collect();
-
-        let inputs = asm.inputs
-            .iter()
-            .map(|&(_, ref input)| self.lower_expr(input))
-            .collect();
-
-        hir::ExprKind::InlineAsm(P(hir_asm), outputs, inputs)
+        let hir_asm = hir::InlineAsm {
+            inner,
+            inputs_exprs: asm.inputs
+                .iter()
+                .map(|&(_, ref input)| self.lower_expr(input))
+                .collect(),
+            outputs_exprs: asm.outputs
+                .iter()
+                .map(|out| self.lower_expr(&out.expr))
+                .collect(),
+        };
+        hir::ExprKind::InlineAsm(P(hir_asm))
     }
 
     fn lower_field(&mut self, f: &Field) -> hir::Field {
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index 465673082e5..17b13dae37f 100644
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -1457,7 +1457,7 @@ pub struct Expr {
 
 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-static_assert_size!(Expr, 72);
+static_assert_size!(Expr, 64);
 
 impl Expr {
     pub fn precedence(&self) -> ExprPrecedence {
@@ -1656,7 +1656,7 @@ pub enum ExprKind {
     Ret(Option<P<Expr>>),
 
     /// Inline assembly (from `asm!`), with its outputs and inputs.
-    InlineAsm(P<InlineAsm>, HirVec<Expr>, HirVec<Expr>),
+    InlineAsm(P<InlineAsm>),
 
     /// A struct or struct-like variant literal expression.
     ///
@@ -2063,7 +2063,7 @@ pub struct InlineAsmOutput {
 // NOTE(eddyb) This is used within MIR as well, so unlike the rest of the HIR,
 // it needs to be `Clone` and use plain `Vec<T>` instead of `HirVec<T>`.
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)]
-pub struct InlineAsm {
+pub struct InlineAsmInner {
     pub asm: Symbol,
     pub asm_str_style: StrStyle,
     pub outputs: Vec<InlineAsmOutput>,
@@ -2074,6 +2074,13 @@ pub struct InlineAsm {
     pub dialect: AsmDialect,
 }
 
+#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
+pub struct InlineAsm {
+    pub inner: InlineAsmInner,
+    pub outputs_exprs: HirVec<Expr>,
+    pub inputs_exprs: HirVec<Expr>,
+}
+
 /// Represents a parameter in a function header.
 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
 pub struct Param {
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
index ba618a1da8c..4cbe0e80991 100644
--- a/src/librustc/hir/print.rs
+++ b/src/librustc/hir/print.rs
@@ -1365,14 +1365,15 @@ impl<'a> State<'a> {
                     self.print_expr_maybe_paren(&expr, parser::PREC_JUMP);
                 }
             }
-            hir::ExprKind::InlineAsm(ref a, ref outputs, ref inputs) => {
+            hir::ExprKind::InlineAsm(ref a) => {
+                let i = &a.inner;
                 self.s.word("asm!");
                 self.popen();
-                self.print_string(&a.asm.as_str(), a.asm_str_style);
+                self.print_string(&i.asm.as_str(), i.asm_str_style);
                 self.word_space(":");
 
                 let mut out_idx = 0;
-                self.commasep(Inconsistent, &a.outputs, |s, out| {
+                self.commasep(Inconsistent, &i.outputs, |s, out| {
                     let constraint = out.constraint.as_str();
                     let mut ch = constraint.chars();
                     match ch.next() {
@@ -1383,7 +1384,7 @@ impl<'a> State<'a> {
                         _ => s.print_string(&constraint, ast::StrStyle::Cooked),
                     }
                     s.popen();
-                    s.print_expr(&outputs[out_idx]);
+                    s.print_expr(&a.outputs_exprs[out_idx]);
                     s.pclose();
                     out_idx += 1;
                 });
@@ -1391,28 +1392,28 @@ impl<'a> State<'a> {
                 self.word_space(":");
 
                 let mut in_idx = 0;
-                self.commasep(Inconsistent, &a.inputs, |s, co| {
+                self.commasep(Inconsistent, &i.inputs, |s, co| {
                     s.print_string(&co.as_str(), ast::StrStyle::Cooked);
                     s.popen();
-                    s.print_expr(&inputs[in_idx]);
+                    s.print_expr(&a.inputs_exprs[in_idx]);
                     s.pclose();
                     in_idx += 1;
                 });
                 self.s.space();
                 self.word_space(":");
 
-                self.commasep(Inconsistent, &a.clobbers, |s, co| {
+                self.commasep(Inconsistent, &i.clobbers, |s, co| {
                     s.print_string(&co.as_str(), ast::StrStyle::Cooked);
                 });
 
                 let mut options = vec![];
-                if a.volatile {
+                if i.volatile {
                     options.push("volatile");
                 }
-                if a.alignstack {
+                if i.alignstack {
                     options.push("alignstack");
                 }
-                if a.dialect == ast::AsmDialect::Intel {
+                if i.dialect == ast::AsmDialect::Intel {
                     options.push("intel");
                 }
 
diff --git a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
index d7cba87e6b1..a431b541fa4 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
@@ -45,7 +45,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     ///
     /// It will later be extended to trait objects.
     pub(super) fn try_report_anon_anon_conflict(&self) -> Option<ErrorReported> {
-        let (span, sub, sup) = self.get_regions();
+        let (span, sub, sup) = self.regions();
 
         // Determine whether the sub and sup consist of both anonymous (elided) regions.
         let anon_reg_sup = self.tcx().is_suitable_region(sup)?;
diff --git a/src/librustc/infer/error_reporting/nice_region_error/mod.rs b/src/librustc/infer/error_reporting/nice_region_error/mod.rs
index cd003aa8dab..09cfbf850a5 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/mod.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/mod.rs
@@ -77,7 +77,7 @@ impl<'cx, 'tcx> NiceRegionError<'cx, 'tcx> {
             .or_else(|| self.try_report_impl_not_conforming_to_trait())
     }
 
-    pub fn get_regions(&self) -> (Span, ty::Region<'tcx>, ty::Region<'tcx>) {
+    pub fn regions(&self) -> (Span, ty::Region<'tcx>, ty::Region<'tcx>) {
         match (&self.error, self.regions) {
             (Some(ConcreteFailure(origin, sub, sup)), None) => (origin.span(), sub, sup),
             (Some(SubSupConflict(_, _, origin, sub, _, sup)), None) => (origin.span(), sub, sup),
diff --git a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
index 36131849191..0abdeb71993 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
@@ -11,7 +11,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     /// When given a `ConcreteFailure` for a function with parameters containing a named region and
     /// an anonymous region, emit an descriptive diagnostic error.
     pub(super) fn try_report_named_anon_conflict(&self) -> Option<DiagnosticBuilder<'a>> {
-        let (span, sub, sup) = self.get_regions();
+        let (span, sub, sup) = self.regions();
 
         debug!(
             "try_report_named_anon_conflict(sub={:?}, sup={:?}, error={:?})",
diff --git a/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs b/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs
index 9d405d4ea40..01ba748c4e1 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs
@@ -20,8 +20,9 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 ) = error.clone()
             {
                 let anon_reg_sup = self.tcx().is_suitable_region(sup_r)?;
+                let return_ty = self.tcx().return_type_impl_trait(anon_reg_sup.def_id);
                 if sub_r == &RegionKind::ReStatic &&
-                    self.tcx().return_type_impl_trait(anon_reg_sup.def_id).is_some()
+                    return_ty.is_some()
                 {
                     let sp = var_origin.span();
                     let return_sp = sub_origin.span();
@@ -52,17 +53,23 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                         }) => name.to_string(),
                         _ => "'_".to_owned(),
                     };
-                    if let Ok(snippet) = self.tcx().sess.source_map().span_to_snippet(return_sp) {
-                        err.span_suggestion(
-                            return_sp,
-                            &format!(
-                                "you can add a constraint to the return type to make it last \
+                    let fn_return_span = return_ty.unwrap().1;
+                    if let Ok(snippet) =
+                        self.tcx().sess.source_map().span_to_snippet(fn_return_span) {
+                        // only apply this suggestion onto functions with
+                        // explicit non-desugar'able return.
+                        if fn_return_span.desugaring_kind().is_none() {
+                            err.span_suggestion(
+                                fn_return_span,
+                                &format!(
+                                    "you can add a constraint to the return type to make it last \
                                  less than `'static` and match {}",
-                                lifetime,
-                            ),
-                            format!("{} + {}", snippet, lifetime_name),
-                            Applicability::Unspecified,
-                        );
+                                 lifetime,
+                                ),
+                                format!("{} + {}", snippet, lifetime_name),
+                                Applicability::Unspecified,
+                            );
+                        }
                     }
                     err.emit();
                     return Some(ErrorReported);
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index 38877dee711..1fc157eca3e 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -36,7 +36,7 @@
 #![feature(core_intrinsics)]
 #![feature(drain_filter)]
 #![cfg_attr(windows, feature(libc))]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(exhaustive_patterns)]
 #![feature(overlapping_marker_traits)]
 #![feature(extern_types)]
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
index bb7ac5d8dbe..4571f551aa4 100644
--- a/src/librustc/middle/expr_use_visitor.rs
+++ b/src/librustc/middle/expr_use_visitor.rs
@@ -283,15 +283,15 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
                 self.borrow_expr(&base, bk);
             }
 
-            hir::ExprKind::InlineAsm(ref ia, ref outputs, ref inputs) => {
-                for (o, output) in ia.outputs.iter().zip(outputs) {
+            hir::ExprKind::InlineAsm(ref ia) => {
+                for (o, output) in ia.inner.outputs.iter().zip(&ia.outputs_exprs) {
                     if o.is_indirect {
                         self.consume_expr(output);
                     } else {
                         self.mutate_expr(output);
                     }
                 }
-                self.consume_exprs(inputs);
+                self.consume_exprs(&ia.inputs_exprs);
             }
 
             hir::ExprKind::Continue(..) |
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index 79468b68055..b7d0f538db5 100644
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -6,7 +6,7 @@
 
 use crate::hir::def::{CtorKind, Namespace};
 use crate::hir::def_id::DefId;
-use crate::hir::{self, InlineAsm as HirInlineAsm};
+use crate::hir;
 use crate::mir::interpret::{PanicInfo, Scalar};
 use crate::mir::visit::MirVisitable;
 use crate::ty::adjustment::PointerCast;
@@ -1638,7 +1638,7 @@ pub enum FakeReadCause {
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
 pub struct InlineAsm<'tcx> {
-    pub asm: HirInlineAsm,
+    pub asm: hir::InlineAsmInner,
     pub outputs: Box<[Place<'tcx>]>,
     pub inputs: Box<[(Span, Operand<'tcx>)]>,
 }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index 41d069bf6ae..95456581169 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -1529,14 +1529,14 @@ impl<'tcx> TyCtxt<'tcx> {
         return Some(FreeRegionInfo {
             def_id: suitable_region_binding_scope,
             boundregion: bound_region,
-            is_impl_item: is_impl_item,
+            is_impl_item,
         });
     }
 
     pub fn return_type_impl_trait(
         &self,
         scope_def_id: DefId,
-    ) -> Option<Ty<'tcx>> {
+    ) -> Option<(Ty<'tcx>, Span)> {
         // HACK: `type_of_def_id()` will fail on these (#55796), so return `None`.
         let hir_id = self.hir().as_local_hir_id(scope_def_id).unwrap();
         match self.hir().get(hir_id) {
@@ -1557,7 +1557,8 @@ impl<'tcx> TyCtxt<'tcx> {
                 let sig = ret_ty.fn_sig(*self);
                 let output = self.erase_late_bound_regions(&sig.output());
                 if output.is_impl_trait() {
-                    Some(output)
+                    let fn_decl = self.hir().fn_decl_by_hir_id(hir_id).unwrap();
+                    Some((output, fn_decl.output.span()))
                 } else {
                     None
                 }
@@ -2440,10 +2441,10 @@ impl<'tcx> TyCtxt<'tcx> {
 
     #[inline]
     pub fn mk_diverging_default(self) -> Ty<'tcx> {
-        if self.features().never_type {
+        if self.features().never_type_fallback {
             self.types.never
         } else {
-            self.intern_tup(&[])
+            self.types.unit
         }
     }
 
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index 972452601dd..b9fc5f59b7b 100644
--- a/src/librustc/ty/layout.rs
+++ b/src/librustc/ty/layout.rs
@@ -697,7 +697,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             // SIMD vector types.
             ty::Adt(def, ..) if def.repr.simd() => {
                 let element = self.layout_of(ty.simd_type(tcx))?;
-                let count = ty.simd_size(tcx) as u64;
+                let count = ty.simd_size(tcx);
                 assert!(count > 0);
                 let scalar = match element.abi {
                     Abi::Scalar(ref scalar) => scalar.clone(),
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
index ccac7720914..8fbd2e4e6b1 100644
--- a/src/librustc/ty/structural_impls.rs
+++ b/src/librustc/ty/structural_impls.rs
@@ -301,7 +301,7 @@ CloneTypeFoldableAndLiftImpls! {
     ::syntax_pos::symbol::Symbol,
     crate::hir::def::Res,
     crate::hir::def_id::DefId,
-    crate::hir::InlineAsm,
+    crate::hir::InlineAsmInner,
     crate::hir::MatchSource,
     crate::hir::Mutability,
     crate::hir::Unsafety,
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
index 07258717cd9..ab6a3bc83b1 100644
--- a/src/librustc/ty/sty.rs
+++ b/src/librustc/ty/sty.rs
@@ -1813,20 +1813,30 @@ impl<'tcx> TyS<'tcx> {
 
     pub fn simd_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self.kind {
-            Adt(def, substs) => {
-                def.non_enum_variant().fields[0].ty(tcx, substs)
-            }
+            Adt(def, substs) => def.non_enum_variant().fields[0].ty(tcx, substs),
             _ => bug!("simd_type called on invalid type")
         }
     }
 
-    pub fn simd_size(&self, _cx: TyCtxt<'_>) -> usize {
+    pub fn simd_size(&self, _tcx: TyCtxt<'tcx>) -> u64 {
+        // Parameter currently unused, but probably needed in the future to
+        // allow `#[repr(simd)] struct Simd<T, const N: usize>([T; N]);`.
         match self.kind {
-            Adt(def, _) => def.non_enum_variant().fields.len(),
+            Adt(def, _) => def.non_enum_variant().fields.len() as u64,
             _ => bug!("simd_size called on invalid type")
         }
     }
 
+    pub fn simd_size_and_type(&self, tcx: TyCtxt<'tcx>) -> (u64, Ty<'tcx>) {
+        match self.kind {
+            Adt(def, substs) => {
+                let variant = def.non_enum_variant();
+                (variant.fields.len() as u64, variant.fields[0].ty(tcx, substs))
+            }
+            _ => bug!("simd_size_and_type called on invalid type")
+        }
+    }
+
     #[inline]
     pub fn is_region_ptr(&self) -> bool {
         match self.kind {
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-05-20 21:52:34 +0000