mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #124624 - WaffleLapkin:old_unit, r=fmease

Browse Source 
Use `tcx.types.unit` instead of `Ty::new_unit(tcx)`

I don't think there is any need for the function, given that we can just access the `.types`, similarly to all other primitives?
This commit is contained in:
Matthias Krüger 2024-05-02 19:42:50 +02:00 committed by GitHub
commit d6940fb43d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 51 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
View File

@ -1223,7 +1223,7 @@ fn get_rust_try_fn<'a, 'gcc, 'tcx>(
tcx,
ty::Binder::dummy(tcx.mk_fn_sig(
iter::once(i8p),
Ty::new_unit(tcx),
tcx.types.unit,
false,
rustc_hir::Unsafety::Unsafe,
Abi::Rust,
@ -1234,7 +1234,7 @@ fn get_rust_try_fn<'a, 'gcc, 'tcx>(
tcx,
ty::Binder::dummy(tcx.mk_fn_sig(
[i8p, i8p].iter().cloned(),
Ty::new_unit(tcx),
tcx.types.unit,
false,
rustc_hir::Unsafety::Unsafe,
Abi::Rust,

4
compiler/rustc_codegen_llvm/src/intrinsic.rs
View File

@ -984,7 +984,7 @@ fn get_rust_try_fn<'ll, 'tcx>(
tcx,
ty::Binder::dummy(tcx.mk_fn_sig(
[i8p],
Ty::new_unit(tcx),
tcx.types.unit,
false,
hir::Unsafety::Unsafe,
Abi::Rust,
@ -995,7 +995,7 @@ fn get_rust_try_fn<'ll, 'tcx>(
tcx,
ty::Binder::dummy(tcx.mk_fn_sig(
[i8p, i8p],
Ty::new_unit(tcx),
tcx.types.unit,
false,
hir::Unsafety::Unsafe,
Abi::Rust,

44
compiler/rustc_hir_analysis/src/check/intrinsic.rs
View File

@ -208,11 +208,11 @@ pub fn check_intrinsic_type(
Ty::new_tup(tcx, &[param(0), tcx.types.bool]),
),
"load" => (1, vec![Ty::new_imm_ptr(tcx, param(0))], param(0)),
"store" => (1, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], Ty::new_unit(tcx)),
"store" => (1, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit),
"xchg" | "xadd" | "xsub" | "and" | "nand" | "or" | "xor" | "max" | "min" | "umax"
| "umin" => (1, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], param(0)),
"fence" | "singlethreadfence" => (0, Vec::new(), Ty::new_unit(tcx)),
"fence" | "singlethreadfence" => (0, Vec::new(), tcx.types.unit),
op => {
tcx.dcx().emit_err(UnrecognizedAtomicOperation { span, op });
return;
@ -224,7 +224,7 @@ pub fn check_intrinsic_type(
let (n_tps, n_cts, inputs, output) = match intrinsic_name {
sym::abort => (0, 0, vec![], tcx.types.never),
sym::unreachable => (0, 0, vec![], tcx.types.never),
sym::breakpoint => (0, 0, vec![], Ty::new_unit(tcx)),
sym::breakpoint => (0, 0, vec![], tcx.types.unit),
sym::size_of | sym::pref_align_of | sym::min_align_of | sym::variant_count => {
(1, 0, vec![], tcx.types.usize)
}
@ -235,14 +235,14 @@ pub fn check_intrinsic_type(
sym::caller_location => (0, 0, vec![], tcx.caller_location_ty()),
sym::assert_inhabited
| sym::assert_zero_valid
| sym::assert_mem_uninitialized_valid => (1, 0, vec![], Ty::new_unit(tcx)),
sym::forget => (1, 0, vec![param(0)], Ty::new_unit(tcx)),
| sym::assert_mem_uninitialized_valid => (1, 0, vec![], tcx.types.unit),
sym::forget => (1, 0, vec![param(0)], tcx.types.unit),
sym::transmute | sym::transmute_unchecked => (2, 0, vec![param(0)], param(1)),
sym::prefetch_read_data
| sym::prefetch_write_data
| sym::prefetch_read_instruction
| sym::prefetch_write_instruction => {
(1, 0, vec![Ty::new_imm_ptr(tcx, param(0)), tcx.types.i32], Ty::new_unit(tcx))
(1, 0, vec![Ty::new_imm_ptr(tcx, param(0)), tcx.types.i32], tcx.types.unit)
}
sym::needs_drop => (1, 0, vec![], tcx.types.bool),
@ -270,7 +270,7 @@ pub fn check_intrinsic_type(
Ty::new_mut_ptr(tcx, param(0)),
tcx.types.usize,
],
Ty::new_unit(tcx),
tcx.types.unit,
),
sym::volatile_copy_memory | sym::volatile_copy_nonoverlapping_memory => (
1,
@ -280,7 +280,7 @@ pub fn check_intrinsic_type(
Ty::new_imm_ptr(tcx, param(0)),
tcx.types.usize,
],
Ty::new_unit(tcx),
tcx.types.unit,
),
sym::compare_bytes => {
let byte_ptr = Ty::new_imm_ptr(tcx, tcx.types.u8);
@ -290,7 +290,7 @@ pub fn check_intrinsic_type(
1,
0,
vec![Ty::new_mut_ptr(tcx, param(0)), tcx.types.u8, tcx.types.usize],
Ty::new_unit(tcx),
tcx.types.unit,
),
sym::sqrtf16 => (0, 0, vec![tcx.types.f16], tcx.types.f16),
@ -409,7 +409,7 @@ pub fn check_intrinsic_type(
(1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], param(0))
}
sym::volatile_store | sym::unaligned_volatile_store => {
(1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], Ty::new_unit(tcx))
(1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
}
sym::ctpop | sym::ctlz | sym::ctlz_nonzero | sym::cttz | sym::cttz_nonzero => {
@ -440,7 +440,7 @@ pub fn check_intrinsic_type(
0,
1,
vec![Ty::new_mut_ptr(tcx, tcx.types.u8), tcx.types.usize, tcx.types.usize],
Ty::new_unit(tcx),
tcx.types.unit,
),
sym::ptr_offset_from => (
@ -477,16 +477,16 @@ pub fn check_intrinsic_type(
| sym::frem_algebraic => (1, 0, vec![param(0), param(0)], param(0)),
sym::float_to_int_unchecked => (2, 0, vec![param(0)], param(1)),
sym::assume => (0, 1, vec![tcx.types.bool], Ty::new_unit(tcx)),
sym::assume => (0, 1, vec![tcx.types.bool], tcx.types.unit),
sym::likely => (0, 1, vec![tcx.types.bool], tcx.types.bool),
sym::unlikely => (0, 1, vec![tcx.types.bool], tcx.types.bool),
sym::read_via_copy => (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], param(0)),
sym::write_via_move => {
(1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], Ty::new_unit(tcx))
(1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
}
sym::typed_swap => (1, 1, vec![Ty::new_mut_ptr(tcx, param(0)); 2], Ty::new_unit(tcx)),
sym::typed_swap => (1, 1, vec![Ty::new_mut_ptr(tcx, param(0)); 2], tcx.types.unit),
sym::discriminant_value => {
let assoc_items = tcx.associated_item_def_ids(
@ -511,14 +511,14 @@ pub fn check_intrinsic_type(
let mut_u8 = Ty::new_mut_ptr(tcx, tcx.types.u8);
let try_fn_ty = ty::Binder::dummy(tcx.mk_fn_sig(
[mut_u8],
Ty::new_unit(tcx),
tcx.types.unit,
false,
hir::Unsafety::Normal,
Abi::Rust,
));
let catch_fn_ty = ty::Binder::dummy(tcx.mk_fn_sig(
[mut_u8, mut_u8],
Ty::new_unit(tcx),
tcx.types.unit,
false,
hir::Unsafety::Normal,
Abi::Rust,
@ -532,14 +532,14 @@ pub fn check_intrinsic_type(
}
sym::va_start | sym::va_end => match mk_va_list_ty(hir::Mutability::Mut) {
Some((va_list_ref_ty, _)) => (0, 0, vec![va_list_ref_ty], Ty::new_unit(tcx)),
Some((va_list_ref_ty, _)) => (0, 0, vec![va_list_ref_ty], tcx.types.unit),
None => bug!("`va_list` lang item needed for C-variadic intrinsics"),
},
sym::va_copy => match mk_va_list_ty(hir::Mutability::Not) {
Some((va_list_ref_ty, va_list_ty)) => {
let va_list_ptr_ty = Ty::new_mut_ptr(tcx, va_list_ty);
(0, 0, vec![va_list_ptr_ty, va_list_ref_ty], Ty::new_unit(tcx))
(0, 0, vec![va_list_ptr_ty, va_list_ref_ty], tcx.types.unit)
}
None => bug!("`va_list` lang item needed for C-variadic intrinsics"),
},
@ -550,7 +550,7 @@ pub fn check_intrinsic_type(
},
sym::nontemporal_store => {
(1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], Ty::new_unit(tcx))
(1, 0, vec![Ty::new_mut_ptr(tcx, param(0)), param(0)], tcx.types.unit)
}
sym::raw_eq => {
@ -570,7 +570,7 @@ pub fn check_intrinsic_type(
sym::const_eval_select => (4, 1, vec![param(0), param(1), param(2)], param(3)),
sym::vtable_size | sym::vtable_align => {
(0, 0, vec![Ty::new_imm_ptr(tcx, Ty::new_unit(tcx))], tcx.types.usize)
(0, 0, vec![Ty::new_imm_ptr(tcx, tcx.types.unit)], tcx.types.usize)
}
// This type check is not particularly useful, but the `where` bounds
@ -623,8 +623,8 @@ pub fn check_intrinsic_type(
sym::simd_fma => (1, 0, vec![param(0), param(0), param(0)], param(0)),
sym::simd_gather => (3, 0, vec![param(0), param(1), param(2)], param(0)),
sym::simd_masked_load => (3, 0, vec![param(0), param(1), param(2)], param(2)),
sym::simd_masked_store => (3, 0, vec![param(0), param(1), param(2)], Ty::new_unit(tcx)),
sym::simd_scatter => (3, 0, vec![param(0), param(1), param(2)], Ty::new_unit(tcx)),
sym::simd_masked_store => (3, 0, vec![param(0), param(1), param(2)], tcx.types.unit),
sym::simd_scatter => (3, 0, vec![param(0), param(1), param(2)], tcx.types.unit),
sym::simd_insert => (2, 0, vec![param(0), tcx.types.u32, param(1)], param(0)),
sym::simd_extract => (2, 0, vec![param(0), tcx.types.u32], param(1)),
sym::simd_cast

2
compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
View File

@ -2370,7 +2370,7 @@ pub fn lower_fn_ty(
self.lower_ty(output)
}
}
hir::FnRetTy::DefaultReturn(..) => Ty::new_unit(tcx),
hir::FnRetTy::DefaultReturn(..) => tcx.types.unit,
};
debug!(?output_ty);

2
compiler/rustc_hir_typeck/src/_match.rs
View File

@ -66,7 +66,7 @@ pub fn check_match(
// us to give better error messages (pointing to a usually better
// arm for inconsistent arms or to the whole match when a `()` type
// is required).
Expectation::ExpectHasType(ety) if ety != Ty::new_unit(self.tcx) => ety,
Expectation::ExpectHasType(ety) if ety != tcx.types.unit => ety,
_ => self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr.span }),
};
CoerceMany::with_coercion_sites(coerce_first, arms)

2
compiler/rustc_hir_typeck/src/coercion.rs
View File

@ -1462,7 +1462,7 @@ pub fn coerce_forced_unit<'a>(
fcx,
cause,
None,
Ty::new_unit(fcx.tcx),
fcx.tcx.types.unit,
augment_error,
label_unit_as_expected,
)

10
compiler/rustc_hir_typeck/src/expr.rs
View File

@ -654,7 +654,7 @@ fn check_expr_break(
} else {
// Otherwise, this is a break *without* a value. That's
// always legal, and is equivalent to `break ()`.
e_ty = Ty::new_unit(tcx);
e_ty = tcx.types.unit;
cause = self.misc(expr.span);
}
@ -1133,7 +1133,7 @@ fn check_expr_assign(
// The expected type is `bool` but this will result in `()` so we can reasonably
// say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
// The likely cause of this is `if foo = bar { .. }`.
let actual_ty = Ty::new_unit(self.tcx);
let actual_ty = self.tcx.types.unit;
let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
let lhs_ty = self.check_expr(lhs);
let rhs_ty = self.check_expr(rhs);
@ -1256,7 +1256,7 @@ fn check_expr_assign(
if let Err(guar) = (lhs_ty, rhs_ty).error_reported() {
Ty::new_error(self.tcx, guar)
} else {
Ty::new_unit(self.tcx)
self.tcx.types.unit
}
}
@ -1319,7 +1319,7 @@ fn check_expr_loop(
if ctxt.coerce.is_none() && !ctxt.may_break {
self.dcx().span_bug(body.span, "no coercion, but loop may not break");
}
ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| Ty::new_unit(self.tcx))
ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.types.unit)
}
/// Checks a method call.
@ -3174,7 +3174,7 @@ fn check_expr_yield(
self.dcx().emit_err(YieldExprOutsideOfCoroutine { span: expr.span });
// Avoid expressions without types during writeback (#78653).
self.check_expr(value);
Ty::new_unit(self.tcx)
self.tcx.types.unit
}
}
}

6
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -1660,7 +1660,7 @@ pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
hir::StmtKind::Item(_) => {}
hir::StmtKind::Expr(ref expr) => {
// Check with expected type of `()`.
self.check_expr_has_type_or_error(expr, Ty::new_unit(self.tcx), |err| {
self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
if expr.can_have_side_effects() {
self.suggest_semicolon_at_end(expr.span, err);
}
@ -1676,7 +1676,7 @@ pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
}
pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
let unit = Ty::new_unit(self.tcx);
let unit = self.tcx.types.unit;
let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
// if the block produces a `!` value, that can always be
@ -1794,7 +1794,7 @@ pub(in super::super) fn check_block_with_expected(
blk.span,
blk.hir_id,
expected_ty,
Ty::new_unit(self.tcx),
self.tcx.types.unit,
);
}
if !self.err_ctxt().consider_removing_semicolon(

2
compiler/rustc_hir_typeck/src/op.rs
View File

@ -39,7 +39,7 @@ pub fn check_binop_assign(
let ty =
if !lhs_ty.is_ty_var() && !rhs_ty.is_ty_var() && is_builtin_binop(lhs_ty, rhs_ty, op) {
self.enforce_builtin_binop_types(lhs.span, lhs_ty, rhs.span, rhs_ty, op);
Ty::new_unit(self.tcx)
self.tcx.types.unit
} else {
return_ty
};

5
compiler/rustc_lint/src/unit_bindings.rs
View File

@ -1,7 +1,6 @@
use crate::lints::UnitBindingsDiag;
use crate::{LateLintPass, LintContext};
use rustc_hir as hir;
use rustc_middle::ty::Ty;
use rustc_session::{declare_lint, declare_lint_pass};
declare_lint! {
@ -57,8 +56,8 @@ fn check_local(&mut self, cx: &crate::LateContext<'tcx>, local: &'tcx hir::LetSt
&& let Some(init) = local.init
&& let init_ty = tyck_results.expr_ty(init)
&& let local_ty = tyck_results.node_type(local.hir_id)
&& init_ty == Ty::new_unit(cx.tcx)
&& local_ty == Ty::new_unit(cx.tcx)
&& init_ty == cx.tcx.types.unit
&& local_ty == cx.tcx.types.unit
&& local.ty.is_none()
&& !matches!(init.kind, hir::ExprKind::Tup([]))
&& !matches!(local.pat.kind, hir::PatKind::Tuple([], ..))

4
compiler/rustc_middle/src/ty/layout.rs
View File

@ -125,7 +125,7 @@ fn to_ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
F64 => tcx.types.f64,
F128 => tcx.types.f128,
// FIXME(erikdesjardins): handle non-default addrspace ptr sizes
Pointer(_) => Ty::new_mut_ptr(tcx, Ty::new_unit(tcx)),
Pointer(_) => Ty::new_mut_ptr(tcx, tcx.types.unit),
}
}
@ -775,7 +775,7 @@ fn field_ty_or_layout<'tcx>(
// (which may have no non-DST form), and will work as long
// as the `Abi` or `FieldsShape` is checked by users.
if i == 0 {
let nil = Ty::new_unit(tcx);
let nil = tcx.types.unit;
let unit_ptr_ty = if this.ty.is_unsafe_ptr() {
Ty::new_mut_ptr(tcx, nil)
} else {

5
compiler/rustc_middle/src/ty/sty.rs
View File

@ -1750,11 +1750,6 @@ pub fn new_coroutine_witness(
// misc
#[inline]
pub fn new_unit(tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
tcx.types.unit
}
#[inline]
pub fn new_static_str(tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
Ty::new_imm_ref(tcx, tcx.lifetimes.re_static, tcx.types.str_)

2
compiler/rustc_mir_build/src/build/mod.rs
View File

@ -997,7 +997,7 @@ fn get_unit_temp(&mut self) -> Place<'tcx> {
match self.unit_temp {
Some(tmp) => tmp,
None => {
let ty = Ty::new_unit(self.tcx);
let ty = self.tcx.types.unit;
let fn_span = self.fn_span;
let tmp = self.temp(ty, fn_span);
self.unit_temp = Some(tmp);

4
compiler/rustc_mir_build/src/thir/cx/mod.rs
View File

@ -15,7 +15,7 @@
use rustc_hir::Node;
use rustc_middle::middle::region;
use rustc_middle::thir::*;
use rustc_middle::ty::{self, RvalueScopes, Ty, TyCtxt};
use rustc_middle::ty::{self, RvalueScopes, TyCtxt};
pub(crate) fn thir_body(
tcx: TyCtxt<'_>,
@ -39,7 +39,7 @@ pub(crate) fn thir_body(
// It will always be `()` in this case.
if tcx.is_coroutine(owner_def.to_def_id()) && body.params.is_empty() {
cx.thir.params.push(Param {
ty: Ty::new_unit(tcx),
ty: tcx.types.unit,
pat: None,
ty_span: None,
self_kind: None,

2
compiler/rustc_mir_dataflow/src/elaborate_drops.rs
View File

@ -631,7 +631,7 @@ fn destructor_call_block(&mut self, (succ, unwind): (BasicBlock, Unwind)) -> Bas
let ref_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, ty);
let ref_place = self.new_temp(ref_ty);
let unit_temp = Place::from(self.new_temp(Ty::new_unit(tcx)));
let unit_temp = Place::from(self.new_temp(tcx.types.unit));
let result = BasicBlockData {
statements: vec![self.assign(

2
compiler/rustc_mir_transform/src/coroutine.rs
View File

@ -1260,7 +1260,7 @@ fn create_coroutine_drop_shim<'tcx>(
}
// Replace the return variable
body.local_decls[RETURN_PLACE] = LocalDecl::with_source_info(Ty::new_unit(tcx), source_info);
body.local_decls[RETURN_PLACE] = LocalDecl::with_source_info(tcx.types.unit, source_info);
make_coroutine_state_argument_indirect(tcx, &mut body);

2
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View File

@ -781,7 +781,7 @@ fn report_selection_error(
&& self.fallback_has_occurred
{
let predicate = trait_predicate.map_bound(|trait_pred| {
trait_pred.with_self_ty(self.tcx, Ty::new_unit(self.tcx))
trait_pred.with_self_ty(self.tcx, tcx.types.unit)
});
let unit_obligation = obligation.with(tcx, predicate);
if self.predicate_may_hold(&unit_obligation) {

2
compiler/rustc_trait_selection/src/traits/object_safety.rs
View File

@ -519,7 +519,7 @@ fn virtual_call_violations_for_method<'tcx>(
// e.g., `Rc<()>`
let unit_receiver_ty =
receiver_for_self_ty(tcx, receiver_ty, Ty::new_unit(tcx), method.def_id);
receiver_for_self_ty(tcx, receiver_ty, tcx.types.unit, method.def_id);
match abi_of_ty(unit_receiver_ty) {
Some(Abi::Scalar(..)) => (),

2
compiler/rustc_ty_utils/src/abi.rs
View File

@ -854,7 +854,7 @@ fn make_thin_self_ptr<'tcx>(
// we now have a type like `*mut RcBox<dyn Trait>`
// change its layout to that of `*mut ()`, a thin pointer, but keep the same type
// this is understood as a special case elsewhere in the compiler
let unit_ptr_ty = Ty::new_mut_ptr(tcx, Ty::new_unit(tcx));
let unit_ptr_ty = Ty::new_mut_ptr(tcx, tcx.types.unit);
TyAndLayout {
ty: fat_pointer_ty,

2
src/tools/miri/src/machine.rs
View File

@ -380,7 +380,7 @@ fn new(layout_cx: LayoutCx<'tcx, TyCtxt<'tcx>>) -> Result<Self, &'tcx LayoutErro
let mut_raw_ptr = Ty::new_mut_ptr(tcx, tcx.types.unit);
let const_raw_ptr = Ty::new_imm_ptr(tcx, tcx.types.unit);
Ok(Self {
unit: layout_cx.layout_of(Ty::new_unit(tcx))?,
unit: layout_cx.layout_of(tcx.types.unit)?,
i8: layout_cx.layout_of(tcx.types.i8)?,
i16: layout_cx.layout_of(tcx.types.i16)?,
i32: layout_cx.layout_of(tcx.types.i32)?,