nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-21 22:34:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #124629 - matthiaskrgr:rollup-gttvzrg, r=matthiaskrgr

Browse Source 
Rollup of 7 pull requests

Successful merges:

 - #124138 (Ignore LLVM ABI in dlltool tests since those targets don't use dlltool)
 - #124414 (remove extraneous note on `UnableToRunDsymutil` diagnostic)
 - #124579 (Align: add bytes_usize and bits_usize)
 - #124622 (Cleanup: Rid the `rmake` test runners of `extern crate run_make_support;`)
 - #124623 (shallow resolve in orphan check)
 - #124624 (Use `tcx.types.unit` instead of `Ty::new_unit(tcx)`)
 - #124627 (interpret: hide some reexports in rustdoc)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-05-02 18:24:38 +00:00
commit 79734f1db8
65 changed files with 135 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
compiler/rustc_abi/src/lib.rs
View File

@ -742,11 +742,21 @@ impl Align {
1 << self.pow2
}
#[inline]
pub fn bytes_usize(self) -> usize {
self.bytes().try_into().unwrap()
}
#[inline]
pub fn bits(self) -> u64 {
self.bytes() * 8
}
#[inline]
pub fn bits_usize(self) -> usize {
self.bits().try_into().unwrap()
}
/// Computes the best alignment possible for the given offset
/// (the largest power of two that the offset is a multiple of).
///

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,

1
compiler/rustc_codegen_ssa/src/errors.rs
View File

@ -431,7 +431,6 @@ pub struct ProcessingDymutilFailed {
#[derive(Diagnostic)]
#[diag(codegen_ssa_unable_to_run_dsymutil)]
#[note]
pub struct UnableToRunDsymutil {
pub error: Error,
}

1
compiler/rustc_const_eval/src/interpret/mod.rs
View File

@ -18,6 +18,7 @@ mod util;
mod validity;
mod visitor;
#[doc(no_inline)]
pub use rustc_middle::mir::interpret::*; // have all the `interpret` symbols in one place: here
pub use self::eval_context::{format_interp_error, Frame, FrameInfo, InterpCx, StackPopCleanup};

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

1
compiler/rustc_hir_analysis/src/coherence/orphan.rs
View File

@ -330,6 +330,7 @@ fn orphan_check<'tcx>(
};
let Ok(result) = traits::orphan_check_trait_ref::<!>(
&infcx,
trait_ref,
traits::InCrate::Local { mode },
lazily_normalize_ty,

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

@ -2370,7 +2370,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// 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 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} 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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// 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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, '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 @@ impl<'a, 'tcx> FnCtxt<'a, '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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
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 @@ impl<'tcx> LateLintPass<'tcx> for UnitBindings {
&& 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 @@ impl Primitive {
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 @@ where
// (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 @@ impl<'tcx> Ty<'tcx> {
// 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 @@ impl<'a, 'tcx> Builder<'a, '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::HirId;
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 @@ where
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);

12
compiler/rustc_trait_selection/src/solve/assembly/mod.rs
View File

@ -2,7 +2,6 @@
use crate::solve::GoalSource;
use crate::solve::{inspect, EvalCtxt, SolverMode};
use crate::traits::coherence;
use rustc_hir::def_id::DefId;
use rustc_infer::traits::query::NoSolution;
use rustc_middle::traits::solve::inspect::ProbeKind;
@ -769,13 +768,10 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
candidates.extend(self.probe_trait_candidate(CandidateSource::CoherenceUnknowable).enter(
|ecx| {
let trait_ref = goal.predicate.trait_ref(tcx);
let lazily_normalize_ty = |ty| ecx.structurally_normalize_ty(goal.param_env, ty);
match coherence::trait_ref_is_knowable(tcx, trait_ref, lazily_normalize_ty)? {
Ok(()) => Err(NoSolution),
Err(_) => {
ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
}
if ecx.trait_ref_is_knowable(goal.param_env, trait_ref)? {
Err(NoSolution)
} else {
ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
}
},
))

12
compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
View File

@ -27,6 +27,7 @@ use rustc_span::DUMMY_SP;
use std::io::Write;
use std::ops::ControlFlow;
use crate::traits::coherence;
use crate::traits::vtable::{count_own_vtable_entries, prepare_vtable_segments, VtblSegment};
use super::inspect::ProofTreeBuilder;
@ -942,6 +943,17 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
}
}
pub(super) fn trait_ref_is_knowable(
&mut self,
param_env: ty::ParamEnv<'tcx>,
trait_ref: ty::TraitRef<'tcx>,
) -> Result<bool, NoSolution> {
let infcx = self.infcx;
let lazily_normalize_ty = |ty| self.structurally_normalize_ty(param_env, ty);
coherence::trait_ref_is_knowable(infcx, trait_ref, lazily_normalize_ty)
.map(|is_knowable| is_knowable.is_ok())
}
pub(super) fn can_define_opaque_ty(&self, def_id: impl Into<DefId>) -> bool {
self.infcx.can_define_opaque_ty(def_id)
}

53
compiler/rustc_trait_selection/src/traits/coherence.rs
View File

@ -618,19 +618,20 @@ fn try_prove_negated_where_clause<'tcx>(
/// This both checks whether any downstream or sibling crates could
/// implement it and whether an upstream crate can add this impl
/// without breaking backwards compatibility.
#[instrument(level = "debug", skip(tcx, lazily_normalize_ty), ret)]
#[instrument(level = "debug", skip(infcx, lazily_normalize_ty), ret)]
pub fn trait_ref_is_knowable<'tcx, E: Debug>(
tcx: TyCtxt<'tcx>,
infcx: &InferCtxt<'tcx>,
trait_ref: ty::TraitRef<'tcx>,
mut lazily_normalize_ty: impl FnMut(Ty<'tcx>) -> Result<Ty<'tcx>, E>,
) -> Result<Result<(), Conflict>, E> {
if orphan_check_trait_ref(trait_ref, InCrate::Remote, &mut lazily_normalize_ty)?.is_ok() {
if orphan_check_trait_ref(infcx, trait_ref, InCrate::Remote, &mut lazily_normalize_ty)?.is_ok()
{
// A downstream or cousin crate is allowed to implement some
// generic parameters of this trait-ref.
return Ok(Err(Conflict::Downstream));
}
if trait_ref_is_local_or_fundamental(tcx, trait_ref) {
if trait_ref_is_local_or_fundamental(infcx.tcx, trait_ref) {
// This is a local or fundamental trait, so future-compatibility
// is no concern. We know that downstream/cousin crates are not
// allowed to implement a generic parameter of this trait ref,
@ -648,6 +649,7 @@ pub fn trait_ref_is_knowable<'tcx, E: Debug>(
// about future-compatibility, which means that we're OK if
// we are an owner.
if orphan_check_trait_ref(
infcx,
trait_ref,
InCrate::Local { mode: OrphanCheckMode::Proper },
&mut lazily_normalize_ty,
@ -786,38 +788,32 @@ pub struct UncoveredTyParams<'tcx, T> {
///
/// Note that this function is never called for types that have both type
/// parameters and inference variables.
#[instrument(level = "trace", skip(lazily_normalize_ty), ret)]
#[instrument(level = "trace", skip(infcx, lazily_normalize_ty), ret)]
pub fn orphan_check_trait_ref<'tcx, E: Debug>(
infcx: &InferCtxt<'tcx>,
trait_ref: ty::TraitRef<'tcx>,
in_crate: InCrate,
lazily_normalize_ty: impl FnMut(Ty<'tcx>) -> Result<Ty<'tcx>, E>,
) -> Result<Result<(), OrphanCheckErr<'tcx, Ty<'tcx>>>, E> {
if trait_ref.has_infer() && trait_ref.has_param() {
bug!(
"can't orphan check a trait ref with both params and inference variables {:?}",
trait_ref
);
if trait_ref.has_param() {
bug!("orphan check only expects inference variables: {trait_ref:?}");
}
let mut checker = OrphanChecker::new(in_crate, lazily_normalize_ty);
// Does there exist some local type after the `ParamTy`.
let search_first_local_ty = |checker: &mut OrphanChecker<'tcx, _>| {
checker.search_first_local_ty = true;
match trait_ref.visit_with(checker).break_value() {
Some(OrphanCheckEarlyExit::LocalTy(local_ty)) => Some(local_ty),
_ => None,
}
};
let mut checker = OrphanChecker::new(infcx, in_crate, lazily_normalize_ty);
Ok(match trait_ref.visit_with(&mut checker) {
ControlFlow::Continue(()) => Err(OrphanCheckErr::NonLocalInputType(checker.non_local_tys)),
ControlFlow::Break(residual) => match residual {
OrphanCheckEarlyExit::NormalizationFailure(err) => return Err(err),
OrphanCheckEarlyExit::UncoveredTyParam(ty) => {
// Does there exist some local type after the `ParamTy`.
checker.search_first_local_ty = true;
let local_ty = match trait_ref.visit_with(&mut checker).break_value() {
Some(OrphanCheckEarlyExit::LocalTy(local_ty)) => Some(local_ty),
_ => None,
};
Err(OrphanCheckErr::UncoveredTyParams(UncoveredTyParams {
uncovered: ty,
local_ty: search_first_local_ty(&mut checker),
local_ty,
}))
}
OrphanCheckEarlyExit::LocalTy(_) => Ok(()),
@ -825,7 +821,8 @@ pub fn orphan_check_trait_ref<'tcx, E: Debug>(
})
}
struct OrphanChecker<'tcx, F> {
struct OrphanChecker<'a, 'tcx, F> {
infcx: &'a InferCtxt<'tcx>,
in_crate: InCrate,
in_self_ty: bool,
lazily_normalize_ty: F,
@ -834,12 +831,13 @@ struct OrphanChecker<'tcx, F> {
non_local_tys: Vec<(Ty<'tcx>, IsFirstInputType)>,
}
impl<'tcx, F, E> OrphanChecker<'tcx, F>
impl<'a, 'tcx, F, E> OrphanChecker<'a, 'tcx, F>
where
F: FnOnce(Ty<'tcx>) -> Result<Ty<'tcx>, E>,
{
fn new(in_crate: InCrate, lazily_normalize_ty: F) -> Self {
fn new(infcx: &'a InferCtxt<'tcx>, in_crate: InCrate, lazily_normalize_ty: F) -> Self {
OrphanChecker {
infcx,
in_crate,
in_self_ty: true,
lazily_normalize_ty,
@ -878,7 +876,7 @@ enum OrphanCheckEarlyExit<'tcx, E> {
LocalTy(Ty<'tcx>),
}
impl<'tcx, F, E> TypeVisitor<TyCtxt<'tcx>> for OrphanChecker<'tcx, F>
impl<'a, 'tcx, F, E> TypeVisitor<TyCtxt<'tcx>> for OrphanChecker<'a, 'tcx, F>
where
F: FnMut(Ty<'tcx>) -> Result<Ty<'tcx>, E>,
{
@ -889,6 +887,7 @@ where
}
fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
let ty = self.infcx.shallow_resolve(ty);
let ty = match (self.lazily_normalize_ty)(ty) {
Ok(norm_ty) if norm_ty.is_ty_var() => ty,
Ok(norm_ty) => norm_ty,
@ -1149,7 +1148,7 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a, 'tcx> {
};
infcx.probe(|_| {
match trait_ref_is_knowable(infcx.tcx, trait_ref, lazily_normalize_ty) {
match trait_ref_is_knowable(infcx, trait_ref, lazily_normalize_ty) {
Err(()) => {}
Ok(Ok(())) => warn!("expected an unknowable trait ref: {trait_ref:?}"),
Ok(Err(conflict)) => {

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

@ -781,7 +781,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
&& 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_trait_selection/src/traits/select/mod.rs
View File

@ -1497,7 +1497,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// bound regions.
let trait_ref = predicate.skip_binder().trait_ref;
coherence::trait_ref_is_knowable::<!>(self.tcx(), trait_ref, |ty| Ok(ty)).unwrap()
coherence::trait_ref_is_knowable::<!>(self.infcx, trait_ref, |ty| Ok(ty)).unwrap()
}
/// Returns `true` if the global caches can be used.

2
compiler/rustc_transmute/src/layout/tree.rs
View File

@ -266,7 +266,7 @@ pub(crate) mod rustc {
ty::Ref(lifetime, ty, mutability) => {
let ty_and_layout = cx.layout_of(*ty)?;
let align = ty_and_layout.align.abi.bytes() as usize;
let align = ty_and_layout.align.abi.bytes_usize();
let size = ty_and_layout.size.bytes_usize();
Ok(Tree::Ref(Ref {
lifetime: *lifetime,

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,

70
src/tools/compiletest/src/header/needs.rs
View File

@ -119,16 +119,6 @@ pub(super) fn handle_needs(
condition: config.debugger != Some(Debugger::Lldb) || config.lldb_native_rust,
ignore_reason: "ignored on targets without Rust's LLDB",
},
Need {
name: "needs-i686-dlltool",
condition: cache.i686_dlltool,
ignore_reason: "ignored when dlltool for i686 is not present",
},
Need {
name: "needs-x86_64-dlltool",
condition: cache.x86_64_dlltool,
ignore_reason: "ignored when dlltool for x86_64 is not present",
},
Need {
name: "needs-dlltool",
condition: cache.dlltool,
@ -218,27 +208,11 @@ pub(super) struct CachedNeedsConditions {
profiler_support: bool,
xray: bool,
rust_lld: bool,
i686_dlltool: bool,
x86_64_dlltool: bool,
dlltool: bool,
}
impl CachedNeedsConditions {
pub(super) fn load(config: &Config) -> Self {
let path = std::env::var_os("PATH").expect("missing PATH environment variable");
let path = std::env::split_paths(&path).collect::<Vec<_>>();
// On Windows, dlltool.exe is used for all architectures.
#[cfg(windows)]
let dlltool = path.iter().any(|dir| dir.join("dlltool.exe").is_file());
// For non-Windows, there are architecture specific dlltool binaries.
#[cfg(not(windows))]
let i686_dlltool = path.iter().any(|dir| dir.join("i686-w64-mingw32-dlltool").is_file());
#[cfg(not(windows))]
let x86_64_dlltool =
path.iter().any(|dir| dir.join("x86_64-w64-mingw32-dlltool").is_file());
let target = &&*config.target;
let sanitizers = &config.target_cfg().sanitizers;
Self {
@ -278,26 +252,30 @@ impl CachedNeedsConditions {
.join(if config.host.contains("windows") { "rust-lld.exe" } else { "rust-lld" })
.exists(),
#[cfg(windows)]
i686_dlltool: dlltool,
#[cfg(windows)]
x86_64_dlltool: dlltool,
#[cfg(windows)]
dlltool,
// For non-Windows, there are architecture specific dlltool binaries.
#[cfg(not(windows))]
i686_dlltool,
#[cfg(not(windows))]
x86_64_dlltool,
#[cfg(not(windows))]
dlltool: if config.matches_arch("x86") {
i686_dlltool
} else if config.matches_arch("x86_64") {
x86_64_dlltool
} else {
false
},
dlltool: find_dlltool(&config),
}
}
}
fn find_dlltool(config: &Config) -> bool {
let path = std::env::var_os("PATH").expect("missing PATH environment variable");
let path = std::env::split_paths(&path).collect::<Vec<_>>();
// dlltool is used ony by GNU based `*-*-windows-gnu`
if !(config.matches_os("windows") && config.matches_env("gnu") && config.matches_abi("")) {
return false;
}
// On Windows, dlltool.exe is used for all architectures.
// For non-Windows, there are architecture specific dlltool binaries.
let dlltool_found = if cfg!(windows) {
path.iter().any(|dir| dir.join("dlltool.exe").is_file())
} else if config.matches_arch("i686") {
path.iter().any(|dir| dir.join("i686-w64-mingw32-dlltool").is_file())
} else if config.matches_arch("x86_64") {
path.iter().any(|dir| dir.join("x86_64-w64-mingw32-dlltool").is_file())
} else {
false
};
dlltool_found
}

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

@ -89,8 +89,10 @@ mod shims;
// Establish a "crate-wide prelude": we often import `crate::*`.
// Make all those symbols available in the same place as our own.
#[doc(no_inline)]
pub use rustc_const_eval::interpret::*;
// Resolve ambiguity.
#[doc(no_inline)]
pub use rustc_const_eval::interpret::{self, AllocMap, PlaceTy, Provenance as _};
pub use crate::shims::env::{EnvVars, EvalContextExt as _};

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

@ -380,7 +380,7 @@ impl<'mir, 'tcx: 'mir> PrimitiveLayouts<'tcx> {
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)?,

2
tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs
View File

@ -3,8 +3,6 @@
// Check that the `CURRENT_RUSTC_VERSION` placeholder is correctly replaced by the current
// `rustc` version and the `since` property in feature stability gating is properly respected.
extern crate run_make_support;
use std::path::PathBuf;
use run_make_support::{rustc, aux_build};

2
tests/run-make/a-b-a-linker-guard/rmake.rs
View File

@ -3,8 +3,6 @@
// Test that if we build `b` against a version of `a` that has one set of types, it will not run
// with a dylib that has a different set of types.
extern crate run_make_support;
use run_make_support::{run, run_fail, rustc};
fn main() {

2
tests/run-make/arguments-non-c-like-enum/rmake.rs
View File

@ -1,8 +1,6 @@
//! Check that non-trivial `repr(C)` enum in Rust has valid C layout.
//@ ignore-cross-compile
extern crate run_make_support;
use run_make_support::{cc, extra_c_flags, extra_cxx_flags, run, rustc, static_lib};
pub fn main() {

2
tests/run-make/artifact-incr-cache-no-obj/rmake.rs
View File

@ -5,8 +5,6 @@
//
// Fixes: rust-lang/rust#123234
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir};
fn main() {

2
tests/run-make/artifact-incr-cache/rmake.rs
View File

@ -7,8 +7,6 @@
// Also see discussion at
// <https://internals.rust-lang.org/t/interaction-between-incremental-compilation-and-emit/20551>
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir};
fn main() {

2
tests/run-make/compiler-builtins/rmake.rs
View File

@ -14,8 +14,6 @@
#![deny(warnings)]
extern crate run_make_support;
use run_make_support::object;
use run_make_support::object::read::archive::ArchiveFile;
use run_make_support::object::read::Object;

2
tests/run-make/core-no-fp-fmt-parse/rmake.rs
View File

@ -1,8 +1,6 @@
// This test checks that the core library of Rust can be compiled without enabling
// support for formatting and parsing floating-point numbers.
extern crate run_make_support;
use run_make_support::rustc;
use std::path::PathBuf;

1
tests/run-make/cross-lang-lto-riscv-abi/rmake.rs
View File

@ -2,7 +2,6 @@
//! which requires extra `target-abi` metadata to be emitted.
//@ needs-matching-clang
//@ needs-llvm-components riscv
extern crate run_make_support;
use run_make_support::{bin_name, clang, llvm_readobj, rustc, tmp_dir};
use std::{

2
tests/run-make/exit-code/rmake.rs
View File

@ -1,7 +1,5 @@
// Test that we exit with the correct exit code for successful / unsuccessful / ICE compilations
extern crate run_make_support;
use run_make_support::{rustc, rustdoc, tmp_dir};
fn main() {

1
tests/run-make/issue-107495-archive-permissions/rmake.rs
View File

@ -2,7 +2,6 @@
#[cfg(unix)]
extern crate libc;
extern crate run_make_support;
use run_make_support::{aux_build, tmp_dir};
use std::fs;

2
tests/run-make/no-input-file/rmake.rs
View File

@ -1,5 +1,3 @@
extern crate run_make_support;
use run_make_support::{diff, rustc};
fn main() {

2
tests/run-make/non-unicode-env/rmake.rs
View File

@ -1,5 +1,3 @@
extern crate run_make_support;
use run_make_support::rustc;
fn main() {

2
tests/run-make/non-unicode-in-incremental-dir/rmake.rs
View File

@ -1,5 +1,3 @@
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir};
fn main() {

2
tests/run-make/print-cfg/rmake.rs
View File

@ -5,8 +5,6 @@
//!
//! It also checks that some targets have the correct set cfgs.
extern crate run_make_support;
use std::collections::HashSet;
use std::ffi::OsString;
use std::io::BufRead;

2
tests/run-make/print-native-static-libs/rmake.rs
View File

@ -12,8 +12,6 @@
//@ ignore-cross-compile
//@ ignore-wasm
extern crate run_make_support;
use std::io::BufRead;
use run_make_support::{rustc, is_msvc};

2
tests/run-make/print-to-output/rmake.rs
View File

@ -1,8 +1,6 @@
//! This checks the output of some `--print` options when
//! output to a file (instead of stdout)
extern crate run_make_support;
use std::ffi::OsString;
use run_make_support::{rustc, target, tmp_dir};

4
tests/run-make/raw-dylib-cross-compilation/Makefile
View File

@ -1,8 +1,6 @@
# Tests that raw-dylib cross compilation works correctly
# only-gnu
# needs-i686-dlltool
# needs-x86_64-dlltool
# needs-dlltool
# i686 dlltool.exe can't product x64 binaries.
# ignore-i686-pc-windows-gnu

2
tests/run-make/repr128-dwarf/rmake.rs
View File

@ -1,8 +1,6 @@
//@ ignore-windows
// This test should be replaced with one in tests/debuginfo once GDB or LLDB support 128-bit enums.
extern crate run_make_support;
use gimli::{AttributeValue, Dwarf, EndianRcSlice, Reader, RunTimeEndian};
use object::{Object, ObjectSection};
use run_make_support::{gimli, object, rustc, tmp_dir};

2
tests/run-make/rust-lld-custom-target/rmake.rs
View File

@ -8,8 +8,6 @@
//@ needs-rust-lld
//@ only-x86_64-unknown-linux-gnu
extern crate run_make_support;
use run_make_support::regex::Regex;
use run_make_support::rustc;
use std::process::Output;

2
tests/run-make/rust-lld/rmake.rs
View File

@ -5,8 +5,6 @@
//@ ignore-msvc
//@ ignore-s390x lld does not yet support s390x as target
extern crate run_make_support;
use run_make_support::regex::Regex;
use run_make_support::rustc;
use std::process::Output;

2
tests/run-make/rustdoc-test-args/rmake.rs
View File

@ -1,5 +1,3 @@
extern crate run_make_support;
use run_make_support::{rustdoc, tmp_dir};
use std::path::Path;
use std::{fs, iter};

2
tests/run-make/wasm-abi/rmake.rs
View File

@ -1,8 +1,6 @@
//@ only-wasm32-wasip1
//@ needs-wasmtime
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir};
use std::path::Path;
use std::process::Command;

1
tests/run-make/wasm-custom-section/rmake.rs
View File

@ -1,5 +1,4 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir, wasmparser};
use std::collections::HashMap;

1
tests/run-make/wasm-custom-sections-opt/rmake.rs
View File

@ -1,5 +1,4 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{tmp_dir, wasmparser, rustc};
use std::collections::HashMap;

2
tests/run-make/wasm-export-all-symbols/rmake.rs
View File

@ -1,7 +1,5 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{tmp_dir, wasmparser, rustc};
use std::collections::HashMap;
use std::path::Path;

2
tests/run-make/wasm-import-module/rmake.rs
View File

@ -1,7 +1,5 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{tmp_dir, wasmparser, rustc};
use std::collections::HashMap;
use wasmparser::TypeRef::Func;

2
tests/run-make/wasm-panic-small/rmake.rs
View File

@ -1,8 +1,6 @@
//@ only-wasm32-wasip1
#![deny(warnings)]
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir};
fn main() {

2
tests/run-make/wasm-spurious-import/rmake.rs
View File

@ -1,7 +1,5 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir, wasmparser};
use std::collections::HashMap;

2
tests/run-make/wasm-stringify-ints-small/rmake.rs
View File

@ -1,8 +1,6 @@
//@ only-wasm32-wasip1
#![deny(warnings)]
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir};
fn main() {

1
tests/run-make/wasm-symbols-different-module/rmake.rs
View File

@ -1,5 +1,4 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir, wasmparser};
use std::collections::{HashMap, HashSet};

1
tests/run-make/wasm-symbols-not-exported/rmake.rs
View File

@ -1,5 +1,4 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir, wasmparser};
use std::path::Path;

1
tests/run-make/wasm-symbols-not-imported/rmake.rs
View File

@ -1,5 +1,4 @@
//@ only-wasm32-wasip1
extern crate run_make_support;
use run_make_support::{rustc, tmp_dir, wasmparser};
use std::path::Path;

2
tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.rs
View File

@ -1,7 +1,5 @@
// Tests that dlltool failing to generate an import library will raise an error.
//@ only-gnu
//@ only-windows
//@ needs-dlltool
//@ compile-flags: --crate-type lib --emit link
//@ normalize-stderr-test: "[^ ']*/dlltool.exe" -> "$$DLLTOOL"

3
tests/ui/rfcs/rfc-2627-raw-dylib/invalid-dlltool.rs
View File

@ -1,7 +1,6 @@
// Tests that failing to run dlltool will raise an error.
//@ only-gnu
//@ only-windows
//@ needs-dlltool
//@ compile-flags: --crate-type lib --emit link -Cdlltool=does_not_exit.exe
#[link(name = "foo", kind = "raw-dylib")]
extern "C" {