Rename InconsistentArgumentType fields, prior -> inconsistent.

Author: jimblandy

naga/src/front/wgsl/error.rs

@@ -328,13 +328,13 @@ pub(crate) enum Error<'a> {
 
         /// The prior argument whose type made the `arg_span` argument
         /// unacceptable.
-        prior_span: Span,
+        inconsistent_span: Span,
 
-        /// The index of the `prior_arg_span` argument.
-        prior_index: u32,
+        /// The index of the `inconsistent_span` argument.
+        inconsistent_index: u32,
 
-        /// The type of the `prior_arg_span` argument.
-        prior_ty: String,
+        /// The type of the `inconsistent_span` argument.
+        inconsistent_ty: String,
 
         /// The types that would have been accepted instead of the
         /// first unacceptable argument.
@@ -945,9 +945,9 @@ impl<'a> Error<'a> {
                 arg_span,
                 arg_index,
                 ref arg_ty,
-                prior_span,
-                prior_index,
-                ref prior_ty,
+                inconsistent_span,
+                inconsistent_index,
+                ref inconsistent_ty,
                 ref allowed
             } => {
                 let message = format!(
@@ -957,12 +957,12 @@ impl<'a> Error<'a> {
                 let labels = vec![
                     (call_span, "".into()),
                     (arg_span, format!("argument #{} has type {arg_ty}", arg_index + 1).into()),
-                    (prior_span, format!(
-                        "this argument has type {prior_ty}, which constrains subsequent arguments"
+                    (inconsistent_span, format!(
+                        "this argument has type {inconsistent_ty}, which constrains subsequent arguments"
                     ).into()),
                 ];
                 let mut notes = vec![
-                    format!("Because argument #{} has type {prior_ty}, only the following types", prior_index + 1),
+                    format!("Because argument #{} has type {inconsistent_ty}, only the following types", inconsistent_index + 1),
                     format!("(or types that automatically convert to them) are accepted for argument #{}:", arg_index + 1),
                 ];
                 notes.extend(allowed.iter().map(|ty| format!("allowed type: {ty}")));

naga/src/front/wgsl/lower/mod.rs

@@ -2569,13 +2569,13 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                             // Re-run the argument list to determine which prior argument
                             // made this one unacceptable.
                             let mut remaining_overloads = fun_overloads;
-                            for (prior_index, &prior_expr) in
+                            for (inconsistent_index, &prior_expr) in
                                 unconverted_arguments.iter().enumerate()
                             {
                                 let prior_ty =
                                     ctx.typifier()[prior_expr].inner_with(&ctx.module.types);
                                 remaining_overloads = remaining_overloads.arg(
-                                    prior_index,
+                                    inconsistent_index,
                                     prior_ty,
                                     &ctx.module.types,
                                 );
@@ -2584,9 +2584,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                                     .is_empty()
                                 {
                                     // This is the argument that killed our dreams.
-                                    let prior_span =
-                                        ctx.ast_expressions.get_span(arguments[prior_index]);
-                                    let prior_ty = ctx.as_diagnostic_display(prior_ty).to_string();
+                                    let inconsistent_span =
+                                        ctx.ast_expressions.get_span(arguments[inconsistent_index]);
+                                    let inconsistent_ty = ctx.as_diagnostic_display(prior_ty).to_string();
 
                                     if allowed.is_empty() {
                                         // Some overloads did accept `ty` at `arg_index`, but
@@ -2607,9 +2607,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                                         arg_span,
                                         arg_index: arg_index as u32,
                                         arg_ty,
-                                        prior_span,
-                                        prior_index: prior_index as u32,
-                                        prior_ty,
+                                        inconsistent_span,
+                                        inconsistent_index: inconsistent_index as u32,
+                                        inconsistent_ty,
                                         allowed,
                                     }));
                                 }