resolve conflicts

resolve conflicts

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index bac69e282a521672ae81467f3ae72581e2aac37c..1aca93fc5c56a990a69f21e611fc6ed12c7c12b2 100644 (file)
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -564,7 +564,7 @@
     }
 
     /// Collects the associated items defined on a trait or impl.
-    query associated_items(key: DefId) -> ty::AssociatedItems<'tcx> {
+    query associated_items(key: DefId) -> ty::AssocItems<'tcx> {
         storage(ArenaCacheSelector<'tcx>)
         desc { |tcx| "collecting associated items of {}", tcx.def_path_str(key) }
     }

diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index d3770fa416b53e0d51fd2dc7b171a2407aaf0e57..d005f63ed4383b4365d9790cd715a8746000547c 100644 (file)
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -96,15 +96,15 @@ pub fn as_def_kind(&self) -> DefKind {
 /// it is relatively expensive. Instead, items are indexed by `Symbol` and hygienic comparison is
 /// done only on items with the same name.
 #[derive(Debug, Clone, PartialEq, HashStable)]
-pub struct AssociatedItems<'tcx> {
+pub struct AssocItems<'tcx> {
     pub(super) items: SortedIndexMultiMap<u32, Symbol, &'tcx ty::AssocItem>,
 }
 
-impl<'tcx> AssociatedItems<'tcx> {
+impl<'tcx> AssocItems<'tcx> {
     /// Constructs an `AssociatedItems` map from a series of `ty::AssocItem`s in definition order.
     pub fn new(items_in_def_order: impl IntoIterator<Item = &'tcx ty::AssocItem>) -> Self {
         let items = items_in_def_order.into_iter().map(|item| (item.ident.name, item)).collect();
-        AssociatedItems { items }
+        AssocItems { items }
     }
 
     /// Returns a slice of associated items in the order they were defined.

diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 29f1761b84d2b3e54b4bf5d4340535cf452ab0a4..38e5ce6fd831c686c56856e10a35b6e02b66d863 100644 (file)
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -210,9 +210,9 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] {
     }
 }
 
-fn associated_items(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssociatedItems<'_> {
+fn associated_items(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItems<'_> {
     let items = tcx.associated_item_def_ids(def_id).iter().map(|did| tcx.associated_item(*did));
-    ty::AssociatedItems::new(items)
+    ty::AssocItems::new(items)
 }
 
 fn def_ident_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {

diff --git a/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs b/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs
index 29654099992029e45ce61ca8bd4ea1286c8ee9fd..c69389e7b432b1578de4879b47add8b147c64bb1 100644 (file)
--- a/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs
+++ b/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs
@@ -24,8 +24,8 @@ impl InherentOverlapChecker<'tcx> {
     /// namespace.
     fn impls_have_common_items(
         &self,
-        impl_items1: &ty::AssociatedItems<'_>,
-        impl_items2: &ty::AssociatedItems<'_>,
+        impl_items1: &ty::AssocItems<'_>,
+        impl_items2: &ty::AssocItems<'_>,
     ) -> bool {
         let mut impl_items1 = &impl_items1;
         let mut impl_items2 = &impl_items2;

diff --git a/test.rs b/test.rs
deleted file mode 100644 (file)
index bc7f5af..0000000
--- a/test.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-#![allow(missing_docs)]
-
-use embedded_hal::digital::v2::{InputPin, OutputPin};
-use generic_array::{ArrayLength, GenericArray};
-use heapless::Vec;
-
-pub trait HeterogenousArray {
-    type Len;
-}
-
-/// Macro to implement a iterator on trait objects from a tuple struct.
-#[macro_export]
-macro_rules! impl_heterogenous_array {
-    ($s:ident, $t:ty, $len:tt, [$($idx:tt),+]) => {
-        impl<'a> IntoIterator for &'a $s {
-            type Item = &'a $t;
-            type IntoIter = generic_array::GenericArrayIter<&'a $t, $len>;
-            fn into_iter(self) -> Self::IntoIter {
-                self.as_array().into_iter()
-            }
-        }
-        impl<'a> IntoIterator for &'a mut $s {
-            type Item = &'a mut $t;
-            type IntoIter = generic_array::GenericArrayIter<&'a mut $t, $len>;
-            fn into_iter(self) -> Self::IntoIter {
-                self.as_mut_array().into_iter()
-            }
-        }
-        impl $crate::matrix::HeterogenousArray for $s {
-            type Len = $len;
-        }
-        impl $s {
-            pub fn as_array(&self) -> generic_array::GenericArray<&$t, $len> {
-                generic_array::arr![&$t; $( &self.$idx as &$t, )+]
-            }
-            pub fn as_mut_array(&mut self) -> generic_array::GenericArray<&mut $t, $len> {
-                generic_array::arr![&mut $t; $( &mut self.$idx as &mut $t, )+]
-            }
-        }
-    }
-}
-
-pub struct Matrix<C, R> {
-    cols: C,
-    rows: R,
-}
-
-impl<C, R> Matrix<C, R> {
-    pub fn new<E>(cols: C, rows: R) -> Result<Self, E>
-        where
-                for<'a> &'a mut R: IntoIterator<Item = &'a mut dyn OutputPin<Error = E>>,
-    {
-        let mut res = Self { cols, rows };
-        res.clear()?;
-        Ok(res)
-    }
-    pub fn clear<'a, E: 'a>(&'a mut self) -> Result<(), E>
-        where
-            &'a mut R: IntoIterator<Item = &'a mut dyn OutputPin<Error = E>>,
-    {
-        for r in self.rows.into_iter() {
-            r.set_high()?;
-        }
-        Ok(())
-    }
-    pub fn get<'a, E: 'a>(&'a mut self) -> Result<PressedKeys<R::Len, C::Len>, E>
-        where
-            &'a mut R: IntoIterator<Item = &'a mut dyn OutputPin<Error = E>>,
-            R: HeterogenousArray,
-            R::Len: ArrayLength<GenericArray<bool, C::Len>>,
-            &'a C: IntoIterator<Item = &'a dyn InputPin<Error = E>>,
-            C: HeterogenousArray,
-            C::Len: ArrayLength<bool>,
-    {
-        let cols = &self.cols;
-        self.rows
-            .into_iter()
-            .map(|r| {
-                r.set_low()?;
-                let col = cols
-                    .into_iter()
-                    .map(|c| c.is_low())
-                    .collect::<Result<Vec<_, C::Len>, E>>()?
-                    .into_iter()
-                    .collect();
-                r.set_high()?;
-                Ok(col)
-            })
-            .collect::<Result<Vec<_, R::Len>, E>>()
-            .map(|res| PressedKeys(res.into_iter().collect()))
-    }
-}
-
-#[derive(Default, PartialEq, Eq)]
-pub struct PressedKeys<U, V>(pub GenericArray<GenericArray<bool, V>, U>)
-    where
-        V: ArrayLength<bool>,
-        U: ArrayLength<GenericArray<bool, V>>;
-
-impl<U, V> PressedKeys<U, V>
-    where
-        V: ArrayLength<bool>,
-        U: ArrayLength<GenericArray<bool, V>>,
-{
-    pub fn iter_pressed<'a>(&'a self) -> impl Iterator<Item = (usize, usize)> + Clone + 'a {
-        self.0.iter().enumerate().flat_map(|(i, r)| {
-            r.iter()
-                .enumerate()
-                .filter_map(move |(j, &b)| if b { Some((i, j)) } else { None })
-        })
-    }
-}
-
-impl<'a, U, V> IntoIterator for &'a PressedKeys<U, V>
-    where
-        V: ArrayLength<bool>,
-        U: ArrayLength<GenericArray<bool, V>>,
-        U: ArrayLength<&'a GenericArray<bool, V>>,
-{
-    type IntoIter = core::slice::Iter<'a, GenericArray<bool, V>>;
-    type Item = &'a GenericArray<bool, V>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
-    }
-}
\ No newline at end of file