Skip to content

Commit fa9f489

Browse files
jimblandyjimblandy
committed
simplify signature of Builtin::check_arguments
1 parent 848e7f7 commit fa9f489

File tree

2 files changed

+61
-62
lines changed

2 files changed

+61
-62
lines changed

‎naga/src/proc/builtins.rs

Lines changed: 60 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,10 @@ pub struct Error {
1515
}
1616

1717
impl Builtin {
18-
pub fn check_arguments<'a, I>(&self, actuals: I) -> Result<(), Error>
19-
where I: Iterator<Item = &'a crate::TypeInner> + Clone,
18+
pub fn check_arguments(&self, actuals: &[&crate::TypeInner]) -> Result<(), Error>
2019
{
2120
eprintln!("JIMB: check_arguments");
22-
let actuals = actuals.into_iter();
21+
let actuals = actuals.iter().cloned();
2322

2423
// First, make our own copy of the type variables, with their
2524
// initial, unconstrained type sets.
@@ -475,10 +474,10 @@ fn unary_vec_or_scalar_numeric_scalar() {
475474
use crate::{Scalar, TypeInner};
476475
let builtin = b!((T) -> T where (T: (vecN or scalar<numeric>)));
477476

478-
let ok = builtin.check_arguments([TypeInner::Scalar(Scalar::U32)].iter());
477+
let ok = builtin.check_arguments(&[&TypeInner::Scalar(Scalar::U32)]);
479478
assert!(ok.is_ok());
480479

481-
let err = builtin.check_arguments([TypeInner::Scalar(Scalar::BOOL)].iter());
480+
let err = builtin.check_arguments(&[&TypeInner::Scalar(Scalar::BOOL)]);
482481
assert!(err.is_err());
483482
}
484483

@@ -487,10 +486,10 @@ fn unary_vec_or_scalar_numeric_vector() {
487486
use crate::{Scalar, TypeInner, VectorSize};
488487
let builtin = b!((T) -> T where (T: (vecN or scalar<numeric>)));
489488

490-
let ok = builtin.check_arguments([TypeInner::Vector { size: VectorSize::Tri, scalar: Scalar::F64 }].iter());
489+
let ok = builtin.check_arguments(&[&TypeInner::Vector { size: VectorSize::Tri, scalar: Scalar::F64 }]);
491490
assert!(ok.is_ok());
492491

493-
let err = builtin.check_arguments([TypeInner::Vector { size: VectorSize::Tri, scalar: Scalar::BOOL }].iter());
492+
let err = builtin.check_arguments(&[&TypeInner::Vector { size: VectorSize::Tri, scalar: Scalar::BOOL }]);
494493
assert!(err.is_err());
495494
}
496495

@@ -499,11 +498,11 @@ fn unary_vec_or_scalar_numeric_matrix() {
499498
use crate::{Scalar, TypeInner, VectorSize};
500499
let builtin = b!((T) -> T where (T: (vecN or scalar<numeric>)));
501500

502-
let err = builtin.check_arguments([TypeInner::Matrix {
501+
let err = builtin.check_arguments(&[&TypeInner::Matrix {
503502
columns: VectorSize::Tri,
504503
rows: VectorSize::Tri,
505504
scalar: Scalar::F32,
506-
}].iter());
505+
}]);
507506
assert!(err.is_err());
508507
}
509508

@@ -515,61 +514,61 @@ fn binary_vec_or_scalar_numeric_scalar() {
515514

516515
let builtin = b!((T, T) -> T where (T: (vecN or scalar<numeric>)));
517516

518-
let ok = builtin.check_arguments([
519-
TypeInner::Scalar(Scalar::F32),
520-
TypeInner::Scalar(Scalar::F32),
521-
].iter());
517+
let ok = builtin.check_arguments(&[
518+
&TypeInner::Scalar(Scalar::F32),
519+
&TypeInner::Scalar(Scalar::F32),
520+
]);
522521
assert!(ok.is_ok());
523522

524-
let ok = builtin.check_arguments([
525-
TypeInner::Scalar(Scalar::ABSTRACT_FLOAT),
526-
TypeInner::Scalar(Scalar::F32),
527-
].iter());
523+
let ok = builtin.check_arguments(&[
524+
&TypeInner::Scalar(Scalar::ABSTRACT_FLOAT),
525+
&TypeInner::Scalar(Scalar::F32),
526+
]);
528527
assert!(ok.is_ok());
529528

530-
let ok = builtin.check_arguments([
531-
TypeInner::Scalar(Scalar::F32),
532-
TypeInner::Scalar(Scalar::ABSTRACT_INT),
533-
].iter());
529+
let ok = builtin.check_arguments(&[
530+
&TypeInner::Scalar(Scalar::F32),
531+
&TypeInner::Scalar(Scalar::ABSTRACT_INT),
532+
]);
534533
assert!(ok.is_ok());
535534

536-
let ok = builtin.check_arguments([
537-
TypeInner::Scalar(Scalar::U32),
538-
TypeInner::Scalar(Scalar::U32),
539-
].iter());
535+
let ok = builtin.check_arguments(&[
536+
&TypeInner::Scalar(Scalar::U32),
537+
&TypeInner::Scalar(Scalar::U32),
538+
]);
540539
assert!(ok.is_ok());
541540

542-
let ok = builtin.check_arguments([
543-
TypeInner::Scalar(Scalar::U32),
544-
TypeInner::Scalar(Scalar::ABSTRACT_INT),
545-
].iter());
541+
let ok = builtin.check_arguments(&[
542+
&TypeInner::Scalar(Scalar::U32),
543+
&TypeInner::Scalar(Scalar::ABSTRACT_INT),
544+
]);
546545
assert!(ok.is_ok());
547546

548-
let ok = builtin.check_arguments([
549-
TypeInner::Scalar(Scalar::ABSTRACT_INT),
550-
TypeInner::Scalar(Scalar::U32),
551-
].iter());
547+
let ok = builtin.check_arguments(&[
548+
&TypeInner::Scalar(Scalar::ABSTRACT_INT),
549+
&TypeInner::Scalar(Scalar::U32),
550+
]);
552551
assert!(ok.is_ok());
553552

554553
// Not numeric.
555-
let err = builtin.check_arguments([
556-
TypeInner::Scalar(Scalar::BOOL),
557-
TypeInner::Scalar(Scalar::BOOL),
558-
].iter());
554+
let err = builtin.check_arguments(&[
555+
&TypeInner::Scalar(Scalar::BOOL),
556+
&TypeInner::Scalar(Scalar::BOOL),
557+
]);
559558
assert!(err.is_err());
560559

561560
// Different floating-point types.
562-
let err = builtin.check_arguments([
563-
TypeInner::Scalar(Scalar::F32),
564-
TypeInner::Scalar(Scalar::F64),
565-
].iter());
561+
let err = builtin.check_arguments(&[
562+
&TypeInner::Scalar(Scalar::F32),
563+
&TypeInner::Scalar(Scalar::F64),
564+
]);
566565
assert!(err.is_err());
567566

568567
// Different constructor.
569-
let err = builtin.check_arguments([
570-
TypeInner::Scalar(Scalar::F32),
571-
TypeInner::Vector { size: Vs::Bi, scalar: Scalar::F32 },
572-
].iter());
568+
let err = builtin.check_arguments(&[
569+
&TypeInner::Scalar(Scalar::F32),
570+
&TypeInner::Vector { size: Vs::Bi, scalar: Scalar::F32 },
571+
]);
573572
assert!(err.is_err());
574573
}
575574

@@ -580,30 +579,30 @@ fn binary_vec_or_scalar_numeric_vector() {
580579

581580
let builtin = b!((T, T) -> T where (T: (vecN or scalar<numeric>)));
582581

583-
let ok = builtin.check_arguments([
584-
TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
585-
TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
586-
].iter());
582+
let ok = builtin.check_arguments(&[&
583+
&TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
584+
&TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
585+
]);
587586
assert!(ok.is_ok());
588587

589588
// Different vector sizes.
590-
let err = builtin.check_arguments([
591-
TypeInner::Vector { size: Vs::Bi, scalar: Scalar::F32 },
592-
TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
593-
].iter());
589+
let err = builtin.check_arguments(&[&
590+
&TypeInner::Vector { size: Vs::Bi, scalar: Scalar::F32 },
591+
&TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
592+
]);
594593
assert!(err.is_err());
595594

596595
// Different vector scalars.
597-
let err = builtin.check_arguments([
598-
TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
599-
TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F64 },
600-
].iter());
596+
let err = builtin.check_arguments(&[&
597+
&TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
598+
&TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F64 },
599+
]);
601600
assert!(err.is_err());
602601

603602
// Mix of vectors and scalars.
604-
let err = builtin.check_arguments([
605-
TypeInner::Scalar(Scalar::F32),
606-
TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
607-
].iter());
603+
let err = builtin.check_arguments(&[&
604+
&TypeInner::Scalar(Scalar::F32),
605+
&TypeInner::Vector { size: Vs::Tri, scalar: Scalar::F32 },
606+
]);
608607
assert!(err.is_err());
609608
}

‎naga/src/valid/expression.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1015,7 +1015,7 @@ impl super::Validator {
10151015
_ => unreachable!(),
10161016
};
10171017

1018-
if let Err(err) = info.check_arguments(actual_types.iter().cloned()) {
1018+
if let Err(err) = info.check_arguments(actual_types) {
10191019
return Err(ExpressionError::InvalidArgumentType(
10201020
fun, err.argument_index as u32, actuals[err.argument_index],
10211021
));

0 commit comments

Comments
 (0)