Skip to content

Commit 296ec5f

Browse files
Mark-SimulacrumMark-Simulacrum
committed
Refactor FnSig to contain a Slice for its inputs and outputs.
1 parent 1eab19d commit 296ec5f

File tree

21 files changed

+121
-114
lines changed

21 files changed

+121
-114
lines changed

‎src/librustc/ty/context.rs

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1542,6 +1542,17 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
15421542
}
15431543
}
15441544

1545+
pub fn mk_fn_sig<I>(self, inputs: I, output: I::Item, variadic: bool)
1546+
-> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
1547+
where I: Iterator,
1548+
I::Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>
1549+
{
1550+
inputs.chain(iter::once(output)).intern_with(|xs| ty::FnSig {
1551+
inputs_and_output: self.intern_type_list(xs),
1552+
variadic: variadic
1553+
})
1554+
}
1555+
15451556
pub fn mk_existential_predicates<I: InternAs<[ExistentialPredicate<'tcx>],
15461557
&'tcx Slice<ExistentialPredicate<'tcx>>>>(self, iter: I)
15471558
-> I::Output {

‎src/librustc/ty/relate.rs

Lines changed: 19 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,10 @@ use ty::subst::{Kind, Substs};
1818
use ty::{self, Ty, TyCtxt, TypeFoldable};
1919
use ty::error::{ExpectedFound, TypeError};
2020
use std::rc::Rc;
21+
use std::iter;
2122
use syntax::abi;
2223
use hir as ast;
24+
use rustc_data_structures::accumulate_vec::AccumulateVec;
2325

2426
pub type RelateResult<'tcx, T> = Result<T, TypeError<'tcx>>;
2527

@@ -180,21 +182,30 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> {
180182
-> RelateResult<'tcx, ty::FnSig<'tcx>>
181183
where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'a+'tcx, 'tcx: 'a
182184
{
183-
if a.variadic() != b.variadic() {
185+
if a.variadic != b.variadic {
184186
return Err(TypeError::VariadicMismatch(
185-
expected_found(relation, &a.variadic(), &b.variadic())));
187+
expected_found(relation, &a.variadic, &b.variadic)));
186188
}
187189

188190
if a.inputs().len() != b.inputs().len() {
189191
return Err(TypeError::ArgCount);
190192
}
191193

192-
let inputs = a.inputs().iter().zip(b.inputs()).map(|(&a, &b)| {
193-
relation.relate_with_variance(ty::Contravariant, &a, &b)
194-
}).collect::<Result<Vec<_>, _>>()?;
195-
let output = relation.relate(&a.output(), &b.output())?;
196-
197-
Ok(ty::FnSig::new(inputs, output, a.variadic()))
194+
let inputs_and_output = a.inputs().iter().cloned()
195+
.zip(b.inputs().iter().cloned())
196+
.map(|x| (x, false))
197+
.chain(iter::once(((a.output(), b.output()), true)))
198+
.map(|((a, b), is_output)| {
199+
if is_output {
200+
relation.relate(&a, &b)
201+
} else {
202+
relation.relate_with_variance(ty::Contravariant, &a, &b)
203+
}
204+
}).collect::<Result<AccumulateVec<[_; 8]>, _>>()?;
205+
Ok(ty::FnSig {
206+
inputs_and_output: relation.tcx().intern_type_list(&inputs_and_output),
207+
variadic: a.variadic
208+
})
198209
}
199210
}
200211

‎src/librustc/ty/structural_impls.rs

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -232,10 +232,11 @@ impl<'a, 'tcx> Lift<'tcx> for ty::adjustment::AutoBorrow<'a> {
232232
impl<'a, 'tcx> Lift<'tcx> for ty::FnSig<'a> {
233233
type Lifted = ty::FnSig<'tcx>;
234234
fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
235-
tcx.lift(self.inputs()).and_then(|inputs| {
236-
tcx.lift(&self.output()).map(|output| {
237-
ty::FnSig::new(inputs, output, self.variadic())
238-
})
235+
tcx.lift(&self.inputs_and_output).map(|x| {
236+
ty::FnSig {
237+
inputs_and_output: x,
238+
variadic: self.variadic
239+
}
239240
})
240241
}
241242
}
@@ -585,17 +586,20 @@ impl<'tcx> TypeFoldable<'tcx> for ty::TypeAndMut<'tcx> {
585586

586587
impl<'tcx> TypeFoldable<'tcx> for ty::FnSig<'tcx> {
587588
fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
588-
ty::FnSig::new(self.inputs().to_owned().fold_with(folder),
589-
self.output().fold_with(folder),
590-
self.variadic())
589+
let inputs_and_output = self.inputs_and_output.fold_with(folder);
590+
ty::FnSig {
591+
inputs_and_output: folder.tcx().intern_type_list(&inputs_and_output),
592+
variadic: self.variadic,
593+
}
591594
}
592595

593596
fn fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
594597
folder.fold_fn_sig(self)
595598
}
596599

597600
fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
598-
self.inputs().to_owned().visit_with(visitor) || self.output().visit_with(visitor)
601+
self.inputs().iter().any(|i| i.visit_with(visitor)) ||
602+
self.output().visit_with(visitor)
599603
}
600604
}
601605

‎src/librustc/ty/sty.rs

Lines changed: 10 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -563,40 +563,31 @@ pub struct ClosureTy<'tcx> {
563563
/// - `variadic` indicates whether this is a variadic function. (only true for foreign fns)
564564
#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
565565
pub struct FnSig<'tcx> {
566-
inputs: Vec<Ty<'tcx>>,
567-
output: Ty<'tcx>,
568-
variadic: bool
566+
pub inputs_and_output: &'tcx Slice<Ty<'tcx>>,
567+
pub variadic: bool
569568
}
570569

571570
impl<'tcx> FnSig<'tcx> {
572-
pub fn new(inputs: Vec<Ty<'tcx>>, output: Ty<'tcx>, variadic: bool) -> Self {
573-
FnSig { inputs: inputs, output: output, variadic: variadic }
574-
}
575-
576571
pub fn inputs(&self) -> &[Ty<'tcx>] {
577-
&self.inputs
572+
&self.inputs_and_output[..self.inputs_and_output.len() - 1]
578573
}
579574

580575
pub fn output(&self) -> Ty<'tcx> {
581-
self.output
582-
}
583-
584-
pub fn variadic(&self) -> bool {
585-
self.variadic
576+
self.inputs_and_output[self.inputs_and_output.len() - 1]
586577
}
587578
}
588579

589580
pub type PolyFnSig<'tcx> = Binder<FnSig<'tcx>>;
590581

591582
impl<'tcx> PolyFnSig<'tcx> {
592-
pub fn inputs<'a>(&'a self) -> Binder<&[Ty<'tcx>]> {
593-
Binder(self.0.inputs())
583+
pub fn inputs(&self) -> Binder<&[Ty<'tcx>]> {
584+
Binder(self.skip_binder().inputs())
594585
}
595586
pub fn input(&self, index: usize) -> ty::Binder<Ty<'tcx>> {
596-
self.map_bound_ref(|fn_sig| fn_sig.inputs[index])
587+
self.map_bound_ref(|fn_sig| fn_sig.inputs()[index])
597588
}
598589
pub fn output(&self) -> ty::Binder<Ty<'tcx>> {
599-
self.map_bound_ref(|fn_sig| fn_sig.output.clone())
590+
self.map_bound_ref(|fn_sig| fn_sig.output().clone())
600591
}
601592
pub fn variadic(&self) -> bool {
602593
self.skip_binder().variadic
@@ -1261,8 +1252,8 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
12611252
}
12621253

12631254
// Type accessors for substructures of types
1264-
pub fn fn_args(&self) -> ty::Binder<Vec<Ty<'tcx>>> {
1265-
ty::Binder(self.fn_sig().inputs().skip_binder().iter().cloned().collect::<Vec<_>>())
1255+
pub fn fn_args(&self) -> ty::Binder<&[Ty<'tcx>]> {
1256+
self.fn_sig().inputs()
12661257
}
12671258

12681259
pub fn fn_ret(&self) -> Binder<Ty<'tcx>> {

‎src/librustc/util/ppaux.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -595,7 +595,7 @@ impl<'tcx> fmt::Debug for ty::InstantiatedPredicates<'tcx> {
595595
impl<'tcx> fmt::Display for ty::FnSig<'tcx> {
596596
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
597597
write!(f, "fn")?;
598-
fn_sig(f, self.inputs(), self.variadic(), self.output())
598+
fn_sig(f, self.inputs(), self.variadic, self.output())
599599
}
600600
}
601601

@@ -625,7 +625,7 @@ impl fmt::Debug for ty::RegionVid {
625625

626626
impl<'tcx> fmt::Debug for ty::FnSig<'tcx> {
627627
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
628-
write!(f, "({:?}; variadic: {})->{:?}", self.inputs(), self.variadic(), self.output())
628+
write!(f, "({:?}; variadic: {})->{:?}", self.inputs(), self.variadic, self.output())
629629
}
630630
}
631631

‎src/librustc_driver/test.rs

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -265,15 +265,10 @@ impl<'a, 'gcx, 'tcx> Env<'a, 'gcx, 'tcx> {
265265
}
266266

267267
pub fn t_fn(&self, input_tys: &[Ty<'tcx>], output_ty: Ty<'tcx>) -> Ty<'tcx> {
268-
let input_args = input_tys.iter().cloned().collect();
269268
self.infcx.tcx.mk_fn_ptr(self.infcx.tcx.mk_bare_fn(ty::BareFnTy {
270269
unsafety: hir::Unsafety::Normal,
271270
abi: Abi::Rust,
272-
sig: ty::Binder(ty::FnSig {
273-
inputs: input_args,
274-
output: output_ty,
275-
variadic: false,
276-
}),
271+
sig: ty::Binder(self.infcx.tcx.mk_fn_sig(input_tys.iter().cloned(), output_ty, false)),
277272
}))
278273
}
279274

‎src/librustc_mir/transform/type_check.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -529,7 +529,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
529529
{
530530
debug!("check_call_inputs({:?}, {:?})", sig, args);
531531
if args.len() < sig.inputs().len() ||
532-
(args.len() > sig.inputs().len() && !sig.variadic()) {
532+
(args.len() > sig.inputs().len() && !sig.variadic) {
533533
span_mirbug!(self, term, "call to {:?} with wrong # of args", sig);
534534
}
535535
for (n, (fn_arg, op_arg)) in sig.inputs().iter().zip(args).enumerate() {

‎src/librustc_trans/abi.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -369,7 +369,7 @@ impl FnType {
369369

370370
let mut inputs = sig.inputs();
371371
let extra_args = if abi == RustCall {
372-
assert!(!sig.variadic() && extra_args.is_empty());
372+
assert!(!sig.variadic && extra_args.is_empty());
373373

374374
match sig.inputs().last().unwrap().sty {
375375
ty::TyTuple(ref tupled_arguments) => {
@@ -382,7 +382,7 @@ impl FnType {
382382
}
383383
}
384384
} else {
385-
assert!(sig.variadic() || extra_args.is_empty());
385+
assert!(sig.variadic || extra_args.is_empty());
386386
extra_args
387387
};
388388

@@ -525,7 +525,7 @@ impl FnType {
525525
FnType {
526526
args: args,
527527
ret: ret,
528-
variadic: sig.variadic(),
528+
variadic: sig.variadic,
529529
cconv: cconv
530530
}
531531
}

‎src/librustc_trans/base.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1077,7 +1077,7 @@ pub fn trans_ctor_shim<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
10771077
let dest_val = adt::MaybeSizedValue::sized(dest); // Can return unsized value
10781078
let mut llarg_idx = fcx.fn_ty.ret.is_indirect() as usize;
10791079
let mut arg_idx = 0;
1080-
for (i, arg_ty) in sig.inputs().into_iter().enumerate() {
1080+
for (i, arg_ty) in sig.inputs().iter().enumerate() {
10811081
let lldestptr = adt::trans_field_ptr(bcx, sig.output(), dest_val, Disr::from(disr), i);
10821082
let arg = &fcx.fn_ty.args[arg_idx];
10831083
arg_idx += 1;

‎src/librustc_trans/callee.rs

Lines changed: 9 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ use type_of;
3838
use Disr;
3939
use rustc::ty::{self, Ty, TypeFoldable};
4040
use rustc::hir;
41+
use std::iter;
4142

4243
use syntax_pos::DUMMY_SP;
4344

@@ -329,13 +330,10 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>(
329330

330331
// Make a version with the type of by-ref closure.
331332
let ty::ClosureTy { unsafety, abi, mut sig } = tcx.closure_type(def_id, substs);
332-
sig.0 = ty::FnSig::new({
333-
let mut inputs = sig.0.inputs().to_owned();
334-
inputs.insert(0, ref_closure_ty); // sig has no self type as of yet
335-
inputs
336-
},
333+
sig.0 = tcx.mk_fn_sig(
334+
iter::once(ref_closure_ty).chain(sig.0.inputs().iter().cloned()),
337335
sig.0.output(),
338-
sig.0.variadic()
336+
sig.0.variadic
339337
);
340338
let llref_fn_ty = tcx.mk_fn_ptr(tcx.mk_bare_fn(ty::BareFnTy {
341339
unsafety: unsafety,
@@ -349,14 +347,10 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>(
349347
// Make a version of the closure type with the same arguments, but
350348
// with argument #0 being by value.
351349
assert_eq!(abi, Abi::RustCall);
352-
sig.0 = ty::FnSig::new(
353-
{
354-
let mut inputs = sig.0.inputs().to_owned();
355-
inputs[0] = closure_ty;
356-
inputs
357-
},
350+
sig.0 = tcx.mk_fn_sig(
351+
iter::once(closure_ty).chain(sig.0.inputs().iter().skip(1).cloned()),
358352
sig.0.output(),
359-
sig.0.variadic()
353+
sig.0.variadic
360354
);
361355

362356
let sig = tcx.erase_late_bound_regions_and_normalize(&sig);
@@ -507,8 +501,8 @@ fn trans_fn_pointer_shim<'a, 'tcx>(
507501
};
508502
let sig = tcx.erase_late_bound_regions_and_normalize(sig);
509503
let tuple_input_ty = tcx.intern_tup(sig.inputs());
510-
let sig = ty::FnSig::new(
511-
vec![bare_fn_ty_maybe_ref, tuple_input_ty],
504+
let sig = tcx.mk_fn_sig(
505+
[bare_fn_ty_maybe_ref, tuple_input_ty].iter().cloned(),
512506
sig.output(),
513507
false
514508
);

0 commit comments

Comments
 (0)