You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
81 lines
2.4 KiB
81 lines
2.4 KiB
use crate::syntax::{NamedType, Ty1, Type};
|
|
use proc_macro2::{Ident, Span};
|
|
use std::hash::{Hash, Hasher};
|
|
use syn::Token;
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
pub enum ImplKey<'a> {
|
|
RustBox(NamedImplKey<'a>),
|
|
RustVec(NamedImplKey<'a>),
|
|
UniquePtr(NamedImplKey<'a>),
|
|
SharedPtr(NamedImplKey<'a>),
|
|
WeakPtr(NamedImplKey<'a>),
|
|
CxxVector(NamedImplKey<'a>),
|
|
}
|
|
|
|
#[derive(Copy, Clone)]
|
|
pub struct NamedImplKey<'a> {
|
|
pub begin_span: Span,
|
|
pub rust: &'a Ident,
|
|
pub lt_token: Option<Token![<]>,
|
|
pub gt_token: Option<Token![>]>,
|
|
pub end_span: Span,
|
|
}
|
|
|
|
impl Type {
|
|
pub(crate) fn impl_key(&self) -> Option<ImplKey> {
|
|
if let Type::RustBox(ty) = self {
|
|
if let Type::Ident(ident) = &ty.inner {
|
|
return Some(ImplKey::RustBox(NamedImplKey::new(ty, ident)));
|
|
}
|
|
} else if let Type::RustVec(ty) = self {
|
|
if let Type::Ident(ident) = &ty.inner {
|
|
return Some(ImplKey::RustVec(NamedImplKey::new(ty, ident)));
|
|
}
|
|
} else if let Type::UniquePtr(ty) = self {
|
|
if let Type::Ident(ident) = &ty.inner {
|
|
return Some(ImplKey::UniquePtr(NamedImplKey::new(ty, ident)));
|
|
}
|
|
} else if let Type::SharedPtr(ty) = self {
|
|
if let Type::Ident(ident) = &ty.inner {
|
|
return Some(ImplKey::SharedPtr(NamedImplKey::new(ty, ident)));
|
|
}
|
|
} else if let Type::WeakPtr(ty) = self {
|
|
if let Type::Ident(ident) = &ty.inner {
|
|
return Some(ImplKey::WeakPtr(NamedImplKey::new(ty, ident)));
|
|
}
|
|
} else if let Type::CxxVector(ty) = self {
|
|
if let Type::Ident(ident) = &ty.inner {
|
|
return Some(ImplKey::CxxVector(NamedImplKey::new(ty, ident)));
|
|
}
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
impl<'a> PartialEq for NamedImplKey<'a> {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
PartialEq::eq(self.rust, other.rust)
|
|
}
|
|
}
|
|
|
|
impl<'a> Eq for NamedImplKey<'a> {}
|
|
|
|
impl<'a> Hash for NamedImplKey<'a> {
|
|
fn hash<H: Hasher>(&self, hasher: &mut H) {
|
|
self.rust.hash(hasher);
|
|
}
|
|
}
|
|
|
|
impl<'a> NamedImplKey<'a> {
|
|
fn new(outer: &Ty1, inner: &'a NamedType) -> Self {
|
|
NamedImplKey {
|
|
begin_span: outer.name.span(),
|
|
rust: &inner.rust,
|
|
lt_token: inner.generics.lt_token,
|
|
gt_token: inner.generics.gt_token,
|
|
end_span: outer.rangle.span,
|
|
}
|
|
}
|
|
}
|