Merge #58

58: Add more syntactic types, update rustc impl and general clean up r=xFrednet a=xFrednet

Not a long description, as I feel like nobody is reading these. If you do, please leave me a comment, and I'll go into more detail. I'd also be very happy!!!

Reviews are welcome, but I'll merge it without, if there has been no activity by the next step.

---

Closes #56
Closes #38


Co-authored-by: xFrednet <[email protected]>

Author: bors[bot]

linter_adapter/src/context.rs

@@ -1,7 +1,7 @@
 use linter_api::{
-    ast::{Span, SpanOwner, SymbolId},
+    ast::{item::ItemKind, ItemId, Span, SpanOwner, SymbolId},
     context::DriverCallbacks,
-    ffi,
+    ffi::{self, FfiOption},
     lint::Lint,
 };
 
@@ -32,13 +32,20 @@ impl<'ast> DriverContextWrapper<'ast> {
         DriverCallbacks {
             driver_context: unsafe { &*(self as *const DriverContextWrapper).cast::<()>() },
             emit_lint,
+            item,
             get_span,
             span_snippet,
             symbol_str,
         }
     }
 }
 
+#[allow(improper_ctypes_definitions, reason = "fp because `ItemKind` is non-exhaustive")]
+extern "C" fn item<'ast>(data: &(), id: ItemId) -> FfiOption<ItemKind<'ast>> {
+    let wrapper = unsafe { &*(data as *const ()).cast::<DriverContextWrapper>() };
+    wrapper.driver_cx.item(id).into()
+}
+
 extern "C" fn emit_lint<'ast>(data: &(), lint: &'static Lint, msg: ffi::Str, span: &Span<'ast>) {
     let wrapper = unsafe { &*(data as *const ()).cast::<DriverContextWrapper>() };
     wrapper.driver_cx.emit_lint(lint, (&msg).into(), span);
@@ -60,6 +67,7 @@ extern "C" fn symbol_str<'ast>(data: &(), sym: SymbolId) -> ffi::Str<'ast> {
 }
 
 pub trait DriverContext<'ast> {
+    fn item(&'ast self, id: ItemId) -> Option<ItemKind<'ast>>;
     fn emit_lint(&'ast self, lint: &'static Lint, msg: &str, span: &Span<'ast>);
     fn get_span(&'ast self, owner: &SpanOwner) -> &'ast Span<'ast>;
     fn span_snippet(&'ast self, span: &Span) -> Option<&'ast str>;

linter_api/src/ast/common.rs

@@ -43,28 +43,6 @@ pub enum Applicability {
     Unspecified,
 }
 
-/// Used to indicate the safety. [`Safety::Default`] is the default safe rust mode.
-#[non_exhaustive]
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-pub enum Safety {
-    Default,
-    Unsafe,
-}
-
-#[non_exhaustive]
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-pub enum Constness {
-    Default,
-    Const,
-}
-
-#[non_exhaustive]
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-pub enum Asyncness {
-    Default,
-    Async,
-}
-
 #[non_exhaustive]
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum Abi {
@@ -78,14 +56,6 @@ pub enum Abi {
     Other,
 }
 
-#[repr(C)]
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Mutability {
-    Mut,
-    Not,
-}
-
 pub struct Spanned<'ast, T> {
     pub node: T,
     pub span: &'ast Span<'ast>,

linter_api/src/ast/common/callable.rs

@@ -80,7 +80,7 @@ impl<'ast> Parameter<'ast> {
     }
 
     pub fn ty(&self) -> Option<TyKind<'ast>> {
-        self.ty.get().copied()
+        self.ty.copy()
     }
 
     pub fn span(&self) -> Option<&Span<'ast>> {

linter_api/src/ast/generic.rs

@@ -87,7 +87,8 @@ pub enum GenericArgKind<'ast> {
     // FIXME: Potentualy add a specific `Arg` wrapper for the `Lifetime` and `Type`
 }
 
-/// This represents the generic parameters of a generic item.
+/// This represents the generic parameters of a generic item. The bounds applied
+/// to parameters as the declaration are stored as clauses in this struct.
 ///
 /// ```
 /// # use std::fmt::Debug;

linter_api/src/ast/generic/param.rs

@@ -1,8 +1,8 @@
+use std::marker::PhantomData;
+
 use crate::ast::{GenericId, Span, SpanId, SymbolId};
 use crate::context::with_cx;
-use crate::ffi::{FfiOption, FfiSlice};
-
-use super::{Lifetime, TyParamBound};
+use crate::ffi::FfiOption;
 
 /// A singular generic parameter, like `'a` and `T` in this example:
 ///
@@ -16,6 +16,10 @@ use super::{Lifetime, TyParamBound};
 /// }
 /// ```
 ///
+/// Bounds declared with the parameter, like the `: Copy` in the example above,
+/// are stored in the [`GenericParams`][`super::GenericParams`] of the item, that
+/// introduced this parameter.
+///
 /// See: <https://doc.rust-lang.org/reference/items/generics.html>
 #[repr(C)]
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -63,19 +67,19 @@ pub trait GenericParamData<'ast> {
 #[repr(C)]
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct TyParam<'ast> {
+    _data: PhantomData<&'ast ()>,
     id: GenericId,
     name: SymbolId,
-    bounds: FfiSlice<'ast, TyParamBound<'ast>>,
     span: FfiOption<SpanId>,
 }
 
 #[cfg(feature = "driver-api")]
 impl<'ast> TyParam<'ast> {
-    pub fn new(span: Option<SpanId>, name: SymbolId, id: GenericId, bounds: &'ast [TyParamBound<'ast>]) -> Self {
+    pub fn new(span: Option<SpanId>, name: SymbolId, id: GenericId) -> Self {
         Self {
+            _data: PhantomData,
             id,
             name,
-            bounds: bounds.into(),
             span: span.into(),
         }
     }
@@ -89,10 +93,6 @@ impl<'ast> TyParam<'ast> {
     pub fn name(&self) -> String {
         with_cx(self, |cx| cx.symbol_str(self.name))
     }
-
-    pub fn span(&self) -> Option<&Span<'ast>> {
-        self.span.get().map(|span| with_cx(self, |cx| cx.get_span(*span)))
-    }
 }
 
 impl<'ast> GenericParamData<'ast> for TyParam<'ast> {
@@ -117,19 +117,19 @@ impl<'ast> From<&'ast TyParam<'ast>> for GenericParamKind<'ast> {
 #[repr(C)]
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct LifetimeParam<'ast> {
+    _data: PhantomData<&'ast ()>,
     id: GenericId,
     name: SymbolId,
-    bounds: FfiSlice<'ast, Lifetime<'ast>>,
     span: FfiOption<SpanId>,
 }
 
 #[cfg(feature = "driver-api")]
 impl<'ast> LifetimeParam<'ast> {
-    pub fn new(id: GenericId, name: SymbolId, bounds: &'ast [Lifetime<'ast>], span: Option<SpanId>) -> Self {
+    pub fn new(id: GenericId, name: SymbolId, span: Option<SpanId>) -> Self {
         Self {
+            _data: PhantomData,
             id,
             name,
-            bounds: bounds.into(),
             span: span.into(),
         }
     }
@@ -143,17 +143,6 @@ impl<'ast> LifetimeParam<'ast> {
     pub fn name(&self) -> String {
         with_cx(self, |cx| cx.symbol_str(self.name))
     }
-
-    /// Returns the bounds defined as part of the parameter. For example `'long`
-    /// would be returned as the bound for `'short`.
-    ///
-    /// ```
-    /// fn foo<'long, 'short: 'long>() {}
-    /// //             ^^^^^^^^^^^^
-    /// ```
-    pub fn bounds(&self) -> &'ast [Lifetime<'ast>] {
-        self.bounds.get()
-    }
 }
 
 impl<'ast> GenericParamData<'ast> for LifetimeParam<'ast> {

linter_api/src/ast/item/const_item.rs

@@ -24,7 +24,7 @@ impl<'ast> ConstItem<'ast> {
     }
 
     pub fn body_id(&self) -> Option<BodyId> {
-        self.body_id.get().copied()
+        self.body_id.copy()
     }
 }
 

linter_api/src/ast/item/fn_item.rs

@@ -37,7 +37,7 @@ impl<'ast> FnItem<'ast> {
     }
 
     pub fn body(&self) -> Option<BodyId> {
-        self.body.get().copied()
+        self.body.copy()
     }
 }
 

linter_api/src/ast/item/static_item.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ast::{ty::TyKind, BodyId, Mutability},
+    ast::{ty::TyKind, BodyId},
     ffi::FfiOption,
 };
 
@@ -20,7 +20,7 @@ use super::CommonItemData;
 #[derive(Debug)]
 pub struct StaticItem<'ast> {
     data: CommonItemData<'ast>,
-    mutability: Mutability,
+    is_mut: bool,
     body_id: FfiOption<BodyId>,
     ty: TyKind<'ast>,
 }
@@ -30,7 +30,7 @@ super::impl_item_data!(StaticItem, Static);
 impl<'ast> StaticItem<'ast> {
     /// The mutability of this item
     pub fn is_mutable(&self) -> bool {
-        self.mutability == Mutability::Mut
+        self.is_mut
     }
 
     /// The defined type of this static item
@@ -40,16 +40,16 @@ impl<'ast> StaticItem<'ast> {
 
     /// This returns the [`BodyId`] of the initialization body.
     pub fn body_id(&self) -> Option<BodyId> {
-        self.body_id.get().copied()
+        self.body_id.copy()
     }
 }
 
 #[cfg(feature = "driver-api")]
 impl<'ast> StaticItem<'ast> {
-    pub fn new(data: CommonItemData<'ast>, mutability: Mutability, body_id: Option<BodyId>, ty: TyKind<'ast>) -> Self {
+    pub fn new(data: CommonItemData<'ast>, is_mut: bool, body_id: Option<BodyId>, ty: TyKind<'ast>) -> Self {
         Self {
             data,
-            mutability,
+            is_mut,
             body_id: body_id.into(),
             ty,
         }

linter_api/src/ast/item/ty_alias_item.rs

@@ -40,7 +40,7 @@ impl<'ast> TyAliasItem<'ast> {
     }
 
     pub fn aliased_ty(&self) -> Option<TyKind> {
-        self.aliased_ty.get().copied()
+        self.aliased_ty.copy()
     }
 }
 

linter_api/src/ast/ty.rs

@@ -49,6 +49,12 @@ mod inferred_ty;
 pub use inferred_ty::*;
 mod generic_ty;
 pub use generic_ty::*;
+mod alias_ty;
+pub use alias_ty::*;
+mod self_ty;
+pub use self_ty::*;
+mod relative_ty;
+pub use relative_ty::*;
 
 pub trait TyData<'ast> {
     fn as_kind(&'ast self) -> TyKind<'ast>;
@@ -155,6 +161,11 @@ pub enum TyKind<'ast> {
     Inferred(&'ast InferredTy<'ast>),
     /// A generic type, that has been specified in a surrounding item
     Generic(&'ast GenericTy<'ast>),
+    Alias(&'ast AliasTy<'ast>),
+    /// The `Self` in impl blocks or trait declarations
+    SelfTy(&'ast SelfTy<'ast>),
+    /// A type declared relative to another type, like `Iterator::Item`
+    Relative(&'ast RelativeTy<'ast>),
 }
 
 impl<'ast> TyKind<'ast> {
@@ -216,8 +227,9 @@ impl<'ast> TyKind<'ast> {
 macro_rules! impl_ty_data_fn {
     ($method:ident () -> $return_ty:ty) => {
         impl_ty_data_fn!($method() -> $return_ty,
-        Bool, Num, Text, Never, Tuple, Array, Slice, Struct, Enum, Union,
-        Fn, Closure, Ref, RawPtr, FnPtr, TraitObj, ImplTrait, Inferred, Generic);
+        Bool, Num, Text, Never, Tuple, Array, Slice, Struct, Enum, Union, Fn,
+        Closure, Ref, RawPtr, FnPtr, TraitObj, ImplTrait, Inferred, Generic,
+        Alias, SelfTy, Relative);
     };
     ($method:ident () -> $return_ty:ty $(, $item:ident)+) => {
         pub fn $method(&self) -> $return_ty {

linter_api/src/ast/ty/alias_ty.rs

@@ -0,0 +1,27 @@
+use crate::ast::ItemId;
+
+use super::CommonTyData;
+
+#[repr(C)]
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct AliasTy<'ast> {
+    data: CommonTyData<'ast>,
+    item: ItemId,
+}
+
+super::impl_ty_data!(AliasTy<'ast>, Alias);
+
+impl<'ast> AliasTy<'ast> {
+    /// This returns the [`ItemId`] belonging to the
+    /// [`TyAliasItem`][`super::super::item::TyAliasItem`] that declared this item.
+    pub fn alias_item_id(&self) -> ItemId {
+        self.item
+    }
+}
+
+#[cfg(feature = "driver-api")]
+impl<'ast> AliasTy<'ast> {
+    pub fn new(data: CommonTyData<'ast>, item: ItemId) -> Self {
+        Self { data, item }
+    }
+}

linter_api/src/ast/ty/raw_ptr_ty.rs

@@ -1,31 +1,25 @@
-use crate::ast::Mutability;
-
 use super::{CommonTyData, TyKind};
 
 #[repr(C)]
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct RawPtrTy<'ast> {
     data: CommonTyData<'ast>,
-    mutability: Mutability,
+    is_mut: bool,
     inner_ty: TyKind<'ast>,
 }
 
 #[cfg(feature = "driver-api")]
 impl<'ast> RawPtrTy<'ast> {
-    pub fn new(data: CommonTyData<'ast>, mutability: Mutability, inner_ty: TyKind<'ast>) -> Self {
-        Self {
-            data,
-            mutability,
-            inner_ty,
-        }
+    pub fn new(data: CommonTyData<'ast>, is_mut: bool, inner_ty: TyKind<'ast>) -> Self {
+        Self { data, is_mut, inner_ty }
     }
 }
 
 super::impl_ty_data!(RawPtrTy<'ast>, RawPtr);
 
 impl<'ast> RawPtrTy<'ast> {
     pub fn is_mut(&self) -> bool {
-        matches!(self.mutability, Mutability::Mut)
+        self.is_mut
     }
 
     pub fn inner_ty(&self) -> TyKind<'ast> {