chore: apply unused_qualifications lint via `cargo +1.78.0 fix && c…

…argo fmt`

naga/src/back/glsl/features.rs

@@ -345,7 +345,7 @@ impl<'a, W> Writer<'a, W> {
  }
 
  // If the type of this global is a struct
- if let crate::TypeInner::Struct { ref members, .. } =
+ if let TypeInner::Struct { ref members, .. } =
  self.module.types[global.ty].inner
  {
  // Check the last element of the struct to see if it's type uses
@@ -472,7 +472,7 @@ impl<'a, W> Writer<'a, W> {
  // layers queries are also implemented as size queries
  crate::ImageQuery::Size { .. } | crate::ImageQuery::NumLayers => {
  if let TypeInner::Image {
- class: crate::ImageClass::Storage { .. }, ..
+ class: ImageClass::Storage { .. }, ..
  } = *info[image].ty.inner_with(&module.types) {
  features.request(Features::IMAGE_SIZE)
  }
@@ -558,7 +558,7 @@ impl<'a, W> Writer<'a, W> {
 
  fn varying_required_features(&mut self, binding: Option<&Binding>, ty: Handle<Type>) {
  match self.module.types[ty].inner {
- crate::TypeInner::Struct { ref members, .. } => {
+ TypeInner::Struct { ref members, .. } => {
  for member in members {
  self.varying_required_features(member.binding.as_ref(), member.ty);
  }

naga/src/back/glsl/mod.rs

@@ -1248,7 +1248,7 @@ impl<'a, W: Write> Writer<'a, W> {
  self.reflection_names_globals.insert(handle, block_name);
 
  match self.module.types[global.ty].inner {
- crate::TypeInner::Struct { ref members, .. }
+ TypeInner::Struct { ref members, .. }
  if self.module.types[members.last().unwrap().ty]
  .inner
  .is_dynamically_sized(&self.module.types) =>
@@ -1429,7 +1429,7 @@ impl<'a, W: Write> Writer<'a, W> {
  output: bool,
  ) -> Result<(), Error> {
  // For a struct, emit a separate global for each member with a binding.
- if let crate::TypeInner::Struct { ref members, .. } = self.module.types[ty].inner {
+ if let TypeInner::Struct { ref members, .. } = self.module.types[ty].inner {
  for member in members {
  self.write_varying(member.binding.as_ref(), member.ty, output)?;
  }
@@ -1701,7 +1701,7 @@ impl<'a, W: Write> Writer<'a, W> {
  write!(self.out, " {name}")?;
  write!(self.out, " = ")?;
  match self.module.types[arg.ty].inner {
- crate::TypeInner::Struct { ref members, .. } => {
+ TypeInner::Struct { ref members, .. } => {
  self.write_type(arg.ty)?;
  write!(self.out, "(")?;
  for (index, member) in members.iter().enumerate() {
@@ -2186,7 +2186,7 @@ impl<'a, W: Write> Writer<'a, W> {
  if let Some(ref result) = ep.function.result {
  let value = value.unwrap();
  match self.module.types[result.ty].inner {
- crate::TypeInner::Struct { ref members, .. } => {
+ TypeInner::Struct { ref members, .. } => {
  let temp_struct_name = match ctx.expressions[value] {
  crate::Expression::Compose { .. } => {
  let return_struct = "_tmp_return";
@@ -2968,7 +2968,7 @@ impl<'a, W: Write> Writer<'a, W> {
  if let Some(expr) = level {
  let cast_to_int = matches!(
  *ctx.resolve_type(expr, &self.module.types),
- crate::TypeInner::Scalar(crate::Scalar {
+ TypeInner::Scalar(crate::Scalar {
  kind: crate::ScalarKind::Uint,
  ..
  })
@@ -3311,7 +3311,7 @@ impl<'a, W: Write> Writer<'a, W> {
  self.write_expr(arg, ctx)?;
 
  match *ctx.resolve_type(arg, &self.module.types) {
- crate::TypeInner::Vector { size, .. } => write!(
+ TypeInner::Vector { size, .. } => write!(
  self.out,
  ", vec{}(0.0), vec{0}(1.0)",
  back::vector_size_str(size)
@@ -3358,15 +3358,15 @@ impl<'a, W: Write> Writer<'a, W> {
  Mf::Pow => "pow",
  // geometry
  Mf::Dot => match *ctx.resolve_type(arg, &self.module.types) {
- crate::TypeInner::Vector {
+ TypeInner::Vector {
  scalar:
  crate::Scalar {
  kind: crate::ScalarKind::Float,
  ..
  },
  ..
  } => "dot",
- crate::TypeInner::Vector { size, .. } => {
+ TypeInner::Vector { size, .. } => {
  return self.write_dot_product(arg, arg1.unwrap(), size as usize, ctx)
  }
  _ => unreachable!(
@@ -3418,7 +3418,7 @@ impl<'a, W: Write> Writer<'a, W> {
  // bits
  Mf::CountTrailingZeros => {
  match *ctx.resolve_type(arg, &self.module.types) {
- crate::TypeInner::Vector { size, scalar, .. } => {
+ TypeInner::Vector { size, scalar, .. } => {
  let s = back::vector_size_str(size);
  if let crate::ScalarKind::Uint = scalar.kind {
  write!(self.out, "min(uvec{s}(findLSB(")?;
@@ -3430,7 +3430,7 @@ impl<'a, W: Write> Writer<'a, W> {
  write!(self.out, ")), uvec{s}(32u)))")?;
  }
  }
- crate::TypeInner::Scalar(scalar) => {
+ TypeInner::Scalar(scalar) => {
  if let crate::ScalarKind::Uint = scalar.kind {
  write!(self.out, "min(uint(findLSB(")?;
  self.write_expr(arg, ctx)?;
@@ -3448,7 +3448,7 @@ impl<'a, W: Write> Writer<'a, W> {
  Mf::CountLeadingZeros => {
  if self.options.version.supports_integer_functions() {
  match *ctx.resolve_type(arg, &self.module.types) {
- crate::TypeInner::Vector { size, scalar } => {
+ TypeInner::Vector { size, scalar } => {
  let s = back::vector_size_str(size);
 
  if let crate::ScalarKind::Uint = scalar.kind {
@@ -3463,7 +3463,7 @@ impl<'a, W: Write> Writer<'a, W> {
  write!(self.out, ", ivec{s}(0)))")?;
  }
  }
- crate::TypeInner::Scalar(scalar) => {
+ TypeInner::Scalar(scalar) => {
  if let crate::ScalarKind::Uint = scalar.kind {
  write!(self.out, "uint(31 - findMSB(")?;
  } else {
@@ -3479,7 +3479,7 @@ impl<'a, W: Write> Writer<'a, W> {
  };
  } else {
  match *ctx.resolve_type(arg, &self.module.types) {
- crate::TypeInner::Vector { size, scalar } => {
+ TypeInner::Vector { size, scalar } => {
  let s = back::vector_size_str(size);
 
  if let crate::ScalarKind::Uint = scalar.kind {
@@ -3497,7 +3497,7 @@ impl<'a, W: Write> Writer<'a, W> {
  write!(self.out, ", ivec{s}(0u))))")?;
  }
  }
- crate::TypeInner::Scalar(scalar) => {
+ TypeInner::Scalar(scalar) => {
  if let crate::ScalarKind::Uint = scalar.kind {
  write!(self.out, "uint(31.0 - floor(log2(float(")?;
  self.write_expr(arg, ctx)?;
@@ -3605,11 +3605,11 @@ impl<'a, W: Write> Writer<'a, W> {
  // Check if the argument is an unsigned integer and return the vector size
  // in case it's a vector
  let maybe_uint_size = match *ctx.resolve_type(arg, &self.module.types) {
- crate::TypeInner::Scalar(crate::Scalar {
+ TypeInner::Scalar(crate::Scalar {
  kind: crate::ScalarKind::Uint,
  ..
  }) => Some(None),
- crate::TypeInner::Vector {
+ TypeInner::Vector {
  scalar:
  crate::Scalar {
  kind: crate::ScalarKind::Uint,
@@ -4402,7 +4402,7 @@ impl<'a, W: Write> Writer<'a, W> {
  continue;
  }
  match self.module.types[var.ty].inner {
- crate::TypeInner::Image { .. } => {
+ TypeInner::Image { .. } => {
  let tex_name = self.reflection_names_globals[&handle].clone();
  match texture_mapping.entry(tex_name) {
  Entry::Vacant(v) => {
@@ -4438,7 +4438,7 @@ impl<'a, W: Write> Writer<'a, W> {
  //
  // This is potentially a bit wasteful, but the set of types in the program
  // shouldn't be too large.
- let mut layouter = crate::proc::Layouter::default();
+ let mut layouter = proc::Layouter::default();
  layouter.update(self.module.to_ctx()).unwrap();
 
  // We start with the name of the binding itself.
@@ -4466,7 +4466,7 @@ impl<'a, W: Write> Writer<'a, W> {
  &mut self,
  ty: Handle<crate::Type>,
  segments: &mut Vec<String>,
- layouter: &crate::proc::Layouter,
+ layouter: &proc::Layouter,
  offset: &mut u32,
  items: &mut Vec<PushConstantItem>,
  ) {

naga/src/back/hlsl/writer.rs

@@ -162,7 +162,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
  }
  crate::MathFunction::CountLeadingZeros => {
  let inner = info[fun_handle].ty.inner_with(&module.types);
- if let Some(crate::ScalarKind::Sint) = inner.scalar_kind() {
+ if let Some(ScalarKind::Sint) = inner.scalar_kind() {
  self.need_bake_expressions.insert(arg);
  }
  }
@@ -450,7 +450,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
  second_blend_source: false,
  ..
  }) => {
- if stage == Some((crate::ShaderStage::Fragment, Io::Output)) {
+ if stage == Some((ShaderStage::Fragment, Io::Output)) {
  write!(self.out, " : SV_Target{location}")?;
  } else {
  write!(self.out, " : {LOCATION_SEMANTIC}{location}")?;
@@ -994,7 +994,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
  columns,
  scalar,
  } if member.binding.is_none() && rows == crate::VectorSize::Bi => {
- let vec_ty = crate::TypeInner::Vector { size: rows, scalar };
+ let vec_ty = TypeInner::Vector { size: rows, scalar };
  let field_name_key = NameKey::StructMember(handle, index as u32);
 
  for i in 0..columns as u8 {
@@ -2397,7 +2397,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
  left,
  right,
  } if func_ctx.resolve_type(left, &module.types).scalar_kind()
- == Some(crate::ScalarKind::Float) =>
+ == Some(ScalarKind::Float) =>
  {
  write!(self.out, "fmod(")?;
  self.write_expr(module, left, func_ctx)?;
@@ -2408,7 +2408,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
  Expression::Binary { op, left, right } => {
  write!(self.out, "(")?;
  self.write_expr(module, left, func_ctx)?;
- write!(self.out, " {} ", crate::back::binary_operation_str(op))?;
+ write!(self.out, " {} ", back::binary_operation_str(op))?;
  self.write_expr(module, right, func_ctx)?;
  write!(self.out, ")")?;
  }

naga/src/back/msl/mod.rs

@@ -533,7 +533,7 @@ pub fn write_string(
  options: &Options,
  pipeline_options: &PipelineOptions,
 ) -> Result<(String, TranslationInfo), Error> {
- let mut w = writer::Writer::new(String::new());
+ let mut w = Writer::new(String::new());
  let info = w.write(module, info, options, pipeline_options)?;
  Ok((w.finish(), info))
 }

naga/src/back/msl/writer.rs

@@ -1596,7 +1596,7 @@ impl<W: Write> Writer<W> {
  write!(self.out, ")")?;
  }
  crate::Expression::Binary { op, left, right } => {
- let op_str = crate::back::binary_operation_str(op);
+ let op_str = back::binary_operation_str(op);
  let kind = context
  .resolve_type(left)
  .scalar_kind()
@@ -3973,7 +3973,7 @@ impl<W: Write> Writer<W> {
  // mapping.
  let mut flattened_member_names = FastHashMap::default();
  // Varyings' members get their own namespace
- let mut varyings_namer = crate::proc::Namer::default();
+ let mut varyings_namer = proc::Namer::default();
 
  // List all the Naga `EntryPoint`'s `Function`'s arguments,
  // flattening structs into their members. In Metal, we will pass
@@ -4804,7 +4804,7 @@ fn test_stack_size() {
  );
  let _ = module.functions.append(fun, Default::default());
  // analyse the module
- let info = crate::valid::Validator::new(ValidationFlags::empty(), Capabilities::empty())
+ let info = valid::Validator::new(ValidationFlags::empty(), Capabilities::empty())
  .validate(&module)
  .unwrap();
  // process the module

naga/src/back/pipeline_constants.rs

@@ -609,7 +609,7 @@ fn adjust_stmt(new_pos: &[Handle<Expression>], stmt: &mut Statement) {
  }
  adjust(value);
  }
- crate::Statement::Atomic {
+ Statement::Atomic {
  ref mut pointer,
  ref mut value,
  ref mut result,
@@ -728,7 +728,7 @@ fn adjust_stmt(new_pos: &[Handle<Expression>], stmt: &mut Statement) {
 /// [`needs_pre_emit`]: Expression::needs_pre_emit
 /// [`Override`]: Expression::Override
 fn filter_emits_in_block(block: &mut Block, expressions: &Arena<Expression>) {
- let original = std::mem::replace(block, Block::with_capacity(block.len()));
+ let original = mem::replace(block, Block::with_capacity(block.len()));
  for (stmt, span) in original.span_into_iter() {
  match stmt {
  Statement::Emit(range) => {