nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-01-26 14:43:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

resolve conflicts

Browse Source 
resolve conflicts
This commit is contained in:
hi-rustin 2021-04-05 22:54:50 +08:00
parent 115e216067
commit 6c3f5b8535
5 changed files with 8 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_middle/src/query/mod.rs
View File

@ -564,7 +564,7 @@ rustc_queries! {
}
/// 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) }
}

6
compiler/rustc_middle/src/ty/assoc.rs
View File

@ -96,15 +96,15 @@ impl AssocKind {
/// 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.

4
compiler/rustc_ty_utils/src/ty.rs
View File

@ -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> {

4
compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs
View File

@ -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;

125
test.rs
View File

@ -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()
}
}