more functions

Author: jimblandy

naga/src/proc/builtins/anyoverloadset.rs

@@ -1,6 +1,6 @@
 //! Dynamically dispatched [`OverloadSet`]s.
 
-use super::{frexp_modf, list, regular, OverloadSet, Rule};
+use super::{list, regular, OverloadSet, Rule};
 use crate::common::DiagnosticDebug;
 use crate::ir;
 use crate::proc::{GlobalCtx, TypeResolution};
@@ -117,5 +117,4 @@ macro_rules! define_any_overload_set {
 define_any_overload_set! {
     list::List,
     regular::Regular,
-    frexp_modf::FrexpModf,
 }

naga/src/proc/builtins/list.rs

@@ -1,11 +1,12 @@
-//! An overload set represented as a static list.
+//! An [`OverloadSet`] represented as a vector of rules.
 
 use super::one_bits_iter::OneBitsIter;
-use super::{Conclusion, Rule};
+use super::Rule;
 
 use crate::common::DiagnosticDebug;
 use crate::proc::{GlobalCtx, TypeResolution};
 
+use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::fmt;
 
@@ -26,25 +27,19 @@ pub struct List {
     /// is always more preferred than all subsequent rules in the
     /// list. If there is no such arrangement of rules, then you
     /// cannot use `List` to represent the overload set.
-    rules: &'static [StaticRule],
-}
-
-#[derive(Clone)]
-pub struct StaticRule {
-    pub subexpressions: &'static [crate::TypeInner],
-    pub conclusion: crate::TypeInner,
+    rules: Arc<Vec<Rule>>,
 }
 
 impl List {
     #[allow(dead_code)]
-    pub(super) const fn from_rules(rules: &'static [StaticRule]) -> List {
+    pub(super) fn from_rules(rules: Vec<Rule>) -> List {
         List {
             members: len_to_full_mask(rules.len()),
-            rules,
+            rules: Arc::new(rules),
         }
     }
 
-    fn members(&self) -> impl Iterator<Item = (u64, &StaticRule)> {
+    fn members(&self) -> impl Iterator<Item = (u64, &Rule)> {
         OneBitsIter::new(self.members).map(|mask| {
             let index = mask.trailing_zeros() as usize;
             (mask, &self.rules[index])
@@ -53,7 +48,7 @@ impl List {
 
     fn filter<F>(&self, mut pred: F) -> List
     where
-        F: FnMut(&StaticRule) -> bool,
+        F: FnMut(&Rule) -> bool,
     {
         let mut filtered_members = 0;
         for (mask, rule) in self.members() {
@@ -64,20 +59,7 @@ impl List {
 
         List {
             members: filtered_members,
-            rules: self.rules,
-        }
-    }
-}
-
-impl StaticRule {
-    fn to_rule(&self) -> Rule {
-        Rule {
-            subexpressions: self
-                .subexpressions
-                .iter()
-                .map(|inner| TypeResolution::Value(inner.clone()))
-                .collect(),
-            conclusion: Conclusion::Value(self.conclusion.clone()),
+            rules: self.rules.clone(),
         }
     }
 }
@@ -121,6 +103,7 @@ impl super::OverloadSet for List {
                 log::debug!("    considering rule {:?}", DiagnosticDebug((rule, types)));
                 match rule.subexpressions.get(i) {
                     Some(rule_ty) => {
+                        let rule_ty = rule_ty.inner_with(types);
                         if arg_ty.equivalent(rule_ty, types) {
                             log::debug!("    types are equivalent");
                         } else {
@@ -142,6 +125,7 @@ impl super::OverloadSet for List {
                 }
             }
             rule.subexpressions.get(i).is_some_and(|rule_ty| {
+                let rule_ty = rule_ty.inner_with(types);
                 arg_ty.equivalent(rule_ty, types)
                     || arg_ty.automatically_converts_to(rule_ty, types).is_some()
             })
@@ -152,27 +136,25 @@ impl super::OverloadSet for List {
         self.filter(|rule| {
             rule.subexpressions
                 .iter()
-                .all(|arg_ty| !arg_ty.is_abstract(types))
+                .all(|arg_ty| !arg_ty.inner_with(types).is_abstract(types))
         })
     }
 
     fn most_preferred(&self) -> Option<Rule> {
         // As documented for `Self::rules`, whatever rule is first is
         // the most preferred. `OverloadSet` documents this method to
         // panic if the set is empty.
-        let (_, static_rule) = self.members().next().unwrap();
-        Some(static_rule.to_rule())
+        let (_, rule) = self.members().next().unwrap();
+        Some(rule.clone())
     }
 
     fn overload_list(&self, _gctx: &GlobalCtx<'_>) -> Vec<Rule> {
-        self.members()
-            .map(|(_, static_rule)| static_rule.to_rule())
-            .collect()
+        self.members().map(|(_, rule)| rule.clone()).collect()
     }
 
     fn allowed_args(&self, i: usize, _gctx: &GlobalCtx<'_>) -> Vec<TypeResolution> {
         self.members()
-            .map(|(_, rule)| TypeResolution::Value(rule.subexpressions[i].clone()))
+            .map(|(_, rule)| rule.subexpressions[i].clone())
             .collect()
     }
 
@@ -193,26 +175,11 @@ impl fmt::Debug for DiagnosticDebug<(&List, &GlobalCtx<'_>)> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let (list, ctx) = self.0;
 
-        f.debug_map()
+        f.debug_list()
             .entries(
-                list.members().map(|(mask, rule)| {
-                    (DiagnosticDebug((rule, ctx.types)), list.members & mask != 0)
-                }),
+                list.members()
+                    .map(|(_mask, rule)| DiagnosticDebug((rule, ctx.types))),
             )
             .finish()
     }
 }
-
-impl fmt::Debug for DiagnosticDebug<(&StaticRule, &crate::UniqueArena<crate::Type>)> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let (rule, arena) = self.0;
-        f.write_str("(")?;
-        for (i, subexpression) in rule.subexpressions.iter().enumerate() {
-            if i > 0 {
-                f.write_str(", ")?;
-            }
-            write!(f, "{:?}", DiagnosticDebug((subexpression, arena)))?;
-        }
-        write!(f, ") -> {:?}", DiagnosticDebug((&rule.conclusion, arena)))
-    }
-}