API: Add new Identifiable trait

Author: xFrednet

marker_adapter/src/context.rs

@@ -2,16 +2,12 @@
 #![allow(clippy::needless_lifetimes)]
 
 use marker_api::{
-    ast::{
-        item::{Body, ItemKind},
-        ty::SemTyKind,
-        BodyId, ExpnId, ExpnInfo, ExprId, FileInfo, FilePos, ItemId, Span, SpanId, SpanPos, SpanSource, SymbolId,
-        TyDefId,
-    },
+    ast::{ty::SemTyKind, ExpnId, ExpnInfo, ExprId, FileInfo, FilePos, SpanId, SpanPos, SpanSource, SymbolId},
     context::DriverCallbacks,
-    diagnostic::{Diagnostic, EmissionNodeId},
+    diagnostic::Diagnostic,
     ffi::{self, FfiOption},
     lint::{Level, Lint},
+    prelude::*,
 };
 
 /// ### Safety
@@ -59,7 +55,7 @@ impl<'ast> DriverContextWrapper<'ast> {
 
 // False positive because `EmissionNode` are non-exhaustive
 #[allow(improper_ctypes_definitions)]
-extern "C" fn lint_level_at<'ast>(data: &'ast (), lint: &'static Lint, node: EmissionNodeId) -> Level {
+extern "C" fn lint_level_at<'ast>(data: &'ast (), lint: &'static Lint, node: NodeId) -> Level {
     unsafe { as_driver_cx(data) }.lint_level_at(lint, node)
 }
 
@@ -129,7 +125,7 @@ unsafe fn as_driver_cx<'ast>(data: &'ast ()) -> &'ast dyn DriverContext<'ast> {
 }
 
 pub trait DriverContext<'ast> {
-    fn lint_level_at(&'ast self, lint: &'static Lint, node: EmissionNodeId) -> Level;
+    fn lint_level_at(&'ast self, lint: &'static Lint, node: NodeId) -> Level;
     fn emit_diag(&'ast self, diag: &Diagnostic<'_, 'ast>);
 
     fn item(&'ast self, api_id: ItemId) -> Option<ItemKind<'ast>>;

marker_api/src/ast/common/id.rs

@@ -39,6 +39,8 @@ macro_rules! new_id {
 
 use new_id;
 
+use crate::private::Sealed;
+
 new_id!(
     /// This ID uniquely identifies a crate during linting.
     pub CrateId: u32
@@ -144,3 +146,63 @@ new_id! {
     /// This ID uniquely identifies a statement during linting.
     pub StmtId: u64
 }
+
+#[repr(C)]
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy)]
+pub enum NodeId {
+    Expr(ExprId),
+    Item(ItemId),
+    Stmt(StmtId),
+    Body(BodyId),
+    Field(FieldId),
+    Variant(VariantId),
+}
+
+macro_rules! impl_into_node_id_for {
+    ($variant:ident, $ty:ty) => {
+        impl From<$ty> for NodeId {
+            fn from(value: $ty) -> Self {
+                NodeId::$variant(value)
+            }
+        }
+
+        impl From<&$ty> for NodeId {
+            fn from(value: &$ty) -> Self {
+                NodeId::$variant(*value)
+            }
+        }
+    };
+}
+
+impl_into_node_id_for!(Expr, ExprId);
+impl_into_node_id_for!(Item, ItemId);
+impl_into_node_id_for!(Stmt, StmtId);
+impl_into_node_id_for!(Body, BodyId);
+impl_into_node_id_for!(Field, FieldId);
+impl_into_node_id_for!(Variant, VariantId);
+
+pub trait Identifiable: Sealed {
+    /// Returns the [`NodeId`] of the identifiable node
+    fn node_id(&self) -> NodeId;
+}
+
+impl<N: Identifiable> Identifiable for &N {
+    fn node_id(&self) -> NodeId {
+        (*self).node_id()
+    }
+}
+
+macro_rules! impl_identifiable_for {
+    ($ty:ty$(, use $data_trait:path)?) => {
+        impl<'ast> $crate::ast::Identifiable for $ty {
+            fn node_id(&self) -> $crate::ast::NodeId {
+                $(
+                    use $data_trait;
+                )*
+                self.id().into()
+            }
+        }
+    };
+}
+pub(crate) use impl_identifiable_for;

marker_api/src/ast/common/span.rs

@@ -577,6 +577,8 @@ pub trait Spanned<'ast>: Sealed {
     fn span(&self) -> &Span<'ast>;
 }
 
+/// This macro implements the [`Spanned`] trait for data types, that provide a
+/// `span()` method.
 macro_rules! impl_spanned_for {
     ($ty:ty) => {
         impl<'ast> $crate::ast::Spanned<'ast> for $ty {

marker_api/src/ast/expr.rs

@@ -1,6 +1,6 @@
 use crate::{prelude::EmissionNode, private::Sealed, CtorBlocker};
 
-use super::{ty::SemTyKind, ExprId, Span, SpanId, Spanned};
+use super::{ty::SemTyKind, ExprId, Identifiable, Span, SpanId, Spanned};
 
 use std::{fmt::Debug, marker::PhantomData};
 
@@ -27,7 +27,7 @@ pub use unstable_expr::*;
 ///
 /// This trait is only meant to be implemented inside this crate. The `Sealed`
 /// super trait prevents external implementations.
-pub trait ExprData<'ast>: Debug + EmissionNode<'ast> + Spanned<'ast> + Sealed {
+pub trait ExprData<'ast>: Debug + EmissionNode<'ast> + Spanned<'ast> + Identifiable + Sealed {
     /// Returns the [`ExprId`] of this expression.
     fn id(&self) -> ExprId;
 
@@ -90,9 +90,10 @@ impl<'ast> ExprKind<'ast> {
     impl_expr_kind_fn!(ExprKind: precedence() -> ExprPrecedence);
 }
 
-impl Sealed for ExprKind<'_> {}
-crate::diagnostic::impl_emission_node_for_node!(ExprKind<'ast>);
 crate::ast::impl_spanned_for!(ExprKind<'ast>);
+crate::ast::impl_identifiable_for!(ExprKind<'ast>);
+impl<'ast> EmissionNode<'ast> for ExprKind<'ast> {}
+impl Sealed for ExprKind<'_> {}
 
 #[repr(C)]
 #[non_exhaustive]
@@ -116,8 +117,9 @@ impl<'ast> LitExprKind<'ast> {
     impl_expr_kind_fn!(LitExprKind: precedence() -> ExprPrecedence);
 }
 
-crate::diagnostic::impl_emission_node_for_node!(LitExprKind<'ast>);
 crate::ast::impl_spanned_for!(LitExprKind<'ast>);
+crate::ast::impl_identifiable_for!(LitExprKind<'ast>);
+impl<'ast> EmissionNode<'ast> for LitExprKind<'ast> {}
 impl Sealed for LitExprKind<'_> {}
 
 impl<'ast> From<LitExprKind<'ast>> for ExprKind<'ast> {
@@ -332,9 +334,10 @@ macro_rules! impl_expr_data {
                 $crate::context::with_cx(self, |cx| cx.span(self.data.span))
             }
         }
+        impl<'ast> $crate::diagnostic::EmissionNode<'ast> for $self_ty {}
+        $crate::ast::impl_identifiable_for!($self_ty, use $crate::ast::expr::ExprData);
 
         impl<'ast> $crate::private::Sealed for $self_ty {}
-        $crate::diagnostic::impl_emission_node_for_node!($self_ty, use super::ExprData);
 
         impl<'ast> From<&'ast $self_ty> for $crate::ast::expr::ExprKind<'ast> {
             fn from(from: &'ast $self_ty) -> Self {

marker_api/src/ast/item.rs

@@ -5,7 +5,7 @@ use crate::private::Sealed;
 use crate::CtorBlocker;
 
 use super::expr::ExprKind;
-use super::{Ident, ItemId, Span, SpanId, Spanned};
+use super::{Ident, Identifiable, ItemId, Span, SpanId, Spanned};
 
 // Item implementations
 mod extern_crate_item;
@@ -37,7 +37,7 @@ pub use unstable_item::*;
 ///
 /// This trait is only meant to be implemented inside this crate. The `Sealed`
 /// super trait prevents external implementations.
-pub trait ItemData<'ast>: Debug + EmissionNode<'ast> + Spanned<'ast> + Sealed {
+pub trait ItemData<'ast>: Debug + EmissionNode<'ast> + Spanned<'ast> + Identifiable + Sealed {
     /// Returns the [`ItemId`] of this item. This is a unique identifier used for comparison
     /// and to request items from the [`AstContext`](`crate::context::AstContext`).
     fn id(&self) -> ItemId;
@@ -90,8 +90,9 @@ impl<'ast> ItemKind<'ast> {
     impl_item_type_fn!(ItemKind: attrs() -> ());
 }
 
-crate::diagnostic::impl_emission_node_for_node!(ItemKind<'ast>);
 crate::ast::impl_spanned_for!(ItemKind<'ast>);
+crate::ast::impl_identifiable_for!(ItemKind<'ast>);
+impl<'ast> EmissionNode<'ast> for ItemKind<'ast> {}
 impl<'ast> crate::private::Sealed for ItemKind<'ast> {}
 
 #[non_exhaustive]
@@ -112,8 +113,9 @@ impl<'ast> AssocItemKind<'ast> {
     // FIXME: Potentially add a field to the items to optionally store the owner id
 }
 
-crate::diagnostic::impl_emission_node_for_node!(AssocItemKind<'ast>);
 crate::ast::impl_spanned_for!(AssocItemKind<'ast>);
+crate::ast::impl_identifiable_for!(AssocItemKind<'ast>);
+impl<'ast> EmissionNode<'ast> for AssocItemKind<'ast> {}
 impl<'ast> crate::private::Sealed for AssocItemKind<'ast> {}
 
 impl<'ast> From<AssocItemKind<'ast>> for ItemKind<'ast> {
@@ -142,8 +144,9 @@ impl<'ast> ExternItemKind<'ast> {
     impl_item_type_fn!(ExternItemKind: as_item() -> ItemKind<'ast>);
 }
 
-crate::diagnostic::impl_emission_node_for_node!(ExternItemKind<'ast>);
 crate::ast::impl_spanned_for!(ExternItemKind<'ast>);
+crate::ast::impl_identifiable_for!(ExternItemKind<'ast>);
+impl<'ast> EmissionNode<'ast> for ExternItemKind<'ast> {}
 impl<'ast> crate::private::Sealed for ExternItemKind<'ast> {}
 
 impl<'ast> From<ExternItemKind<'ast>> for ItemKind<'ast> {
@@ -223,8 +226,9 @@ macro_rules! impl_item_data {
             }
         }
 
+        $crate::ast::impl_identifiable_for!($self_name<'ast>, use $crate::ast::item::ItemData);
+        impl<'ast> $crate::diagnostic::EmissionNode<'ast> for $self_name<'ast> {}
         impl $crate::private::Sealed for $self_name<'_> {}
-        $crate::diagnostic::impl_emission_node_for_node!($self_name<'ast>, use super::ItemData);
 
         impl<'ast> From<&'ast $self_name<'ast>> for crate::ast::item::ItemKind<'ast> {
             fn from(value: &'ast $self_name<'ast>) -> Self {

marker_api/src/ast/item/adt_item.rs

@@ -4,7 +4,7 @@ use crate::ast::ty::SynTyKind;
 use crate::ast::{FieldId, Span, SpanId, SymbolId, VariantId};
 use crate::context::with_cx;
 use crate::ffi::{FfiOption, FfiSlice};
-use crate::prelude::Spanned;
+use crate::prelude::{EmissionNode, Spanned};
 
 use super::{CommonItemData, Visibility};
 
@@ -172,7 +172,8 @@ impl<'ast> Spanned<'ast> for EnumVariant<'ast> {
     }
 }
 
-crate::diagnostic::impl_emission_node_for_node!(&EnumVariant<'ast>);
+crate::ast::impl_identifiable_for!(EnumVariant<'ast>);
+impl<'ast> EmissionNode<'ast> for EnumVariant<'ast> {}
 impl<'ast> crate::private::Sealed for EnumVariant<'ast> {}
 
 #[cfg(feature = "driver-api")]
@@ -323,7 +324,8 @@ impl<'ast> Spanned<'ast> for Field<'ast> {
     }
 }
 
-crate::diagnostic::impl_emission_node_for_node!(&Field<'ast>);
+crate::ast::impl_identifiable_for!(Field<'ast>);
+impl<'ast> EmissionNode<'ast> for Field<'ast> {}
 impl<'ast> crate::private::Sealed for Field<'ast> {}
 
 #[cfg(feature = "driver-api")]

marker_api/src/ast/stmt.rs

@@ -1,15 +1,15 @@
 use std::fmt::Debug;
 use std::marker::PhantomData;
 
-use crate::{ffi::FfiOption, private::Sealed};
+use crate::{ffi::FfiOption, prelude::EmissionNode, private::Sealed};
 
-use super::{expr::ExprKind, item::ItemKind, pat::PatKind, ty::SynTyKind, Span, SpanId, Spanned, StmtId};
+use super::{expr::ExprKind, item::ItemKind, pat::PatKind, ty::SynTyKind, Identifiable, Span, SpanId, Spanned, StmtId};
 
 /// This trait combines methods, which all statements have in common.
 ///
 /// This trait is only meant to be implemented inside this crate. The `Sealed`
 /// super trait prevents external implementations.
-pub trait StmtData<'ast>: Debug + Spanned<'ast> + Sealed {
+pub trait StmtData<'ast>: Debug + Spanned<'ast> + Identifiable + Sealed {
     /// Returns the [`StmtId`] of this statement
     fn id(&self) -> StmtId;
 }
@@ -48,8 +48,9 @@ impl<'ast> StmtKind<'ast> {
     pub fn attrs(&self) {}
 }
 
-crate::diagnostic::impl_emission_node_for_node!(StmtKind<'ast>);
 crate::ast::impl_spanned_for!(StmtKind<'ast>);
+crate::ast::impl_identifiable_for!(StmtKind<'ast>);
+impl<'ast> EmissionNode<'ast> for StmtKind<'ast> {}
 impl<'ast> crate::private::Sealed for StmtKind<'ast> {}
 
 #[repr(C)]
@@ -82,6 +83,8 @@ macro_rules! impl_stmt_data {
             }
         }
 
+        $crate::ast::impl_identifiable_for!($self_ty, use StmtData);
+
         impl<'ast> From<&'ast $self_ty> for $crate::ast::stmt::StmtKind<'ast> {
             fn from(from: &'ast $self_ty) -> Self {
                 $crate::ast::stmt::StmtKind::$enum_name(from)
@@ -131,7 +134,7 @@ impl<'ast> LetStmt<'ast> {
 }
 
 impl_stmt_data!(LetStmt<'ast>, Let);
-crate::diagnostic::impl_emission_node_for_node!(LetStmt<'ast>);
+impl<'ast> EmissionNode<'ast> for LetStmt<'ast> {}
 
 #[repr(C)]
 #[derive(Debug)]
@@ -148,7 +151,7 @@ impl<'ast> ExprStmt<'ast> {
 }
 
 impl_stmt_data!(ExprStmt<'ast>, Expr);
-crate::diagnostic::impl_emission_node_for_node!(ExprStmt<'ast>);
+impl<'ast> EmissionNode<'ast> for ExprStmt<'ast> {}
 
 #[repr(C)]
 #[derive(Debug)]
@@ -165,4 +168,4 @@ impl<'ast> ItemStmt<'ast> {
 }
 
 impl_stmt_data!(ItemStmt<'ast>, Item);
-crate::diagnostic::impl_emission_node_for_node!(ItemStmt<'ast>);
+impl<'ast> EmissionNode<'ast> for ItemStmt<'ast> {}

marker_api/src/context.rs

@@ -8,10 +8,10 @@ use crate::{
     ast::{
         item::{Body, ItemKind},
         ty::SemTyKind,
-        BodyId, ExpnId, ExpnInfo, ExprId, FileInfo, FilePos, ItemId, Span, SpanId, SpanPos, SpanSource, SymbolId,
-        TyDefId,
+        BodyId, ExpnId, ExpnInfo, ExprId, FileInfo, FilePos, Identifiable, ItemId, NodeId, Span, SpanId, SpanPos,
+        SpanSource, SymbolId, TyDefId,
     },
-    diagnostic::{Diagnostic, DiagnosticBuilder, EmissionNode, EmissionNodeId},
+    diagnostic::{Diagnostic, DiagnosticBuilder, EmissionNode},
     ffi,
     lint::{Level, Lint, MacroReport},
 };
@@ -101,8 +101,8 @@ impl<'ast> AstContext<'ast> {
 }
 
 impl<'ast> AstContext<'ast> {
-    pub fn lint_level_at(&self, lint: &'static Lint, node: impl EmissionNode<'ast>) -> Level {
-        self.driver.call_lint_level_at(lint, node.emission_node_id())
+    pub fn lint_level_at(&self, lint: &'static Lint, node: impl Identifiable) -> Level {
+        self.driver.call_lint_level_at(lint, node.node_id())
     }
 
     /// This function is used to emit a lint.
@@ -214,7 +214,7 @@ impl<'ast> AstContext<'ast> {
         node: impl EmissionNode<'ast>,
         msg: impl Into<String>,
     ) -> DiagnosticBuilder<'ast> {
-        let id = node.emission_node_id();
+        let id = node.node_id();
         let span = node.span();
         if matches!(lint.report_in_macro, MacroReport::No) && span.is_from_expansion() {
             return DiagnosticBuilder::new_dummy(lint, id);
@@ -335,7 +335,7 @@ struct DriverCallbacks<'ast> {
     // can't call them in safe Rust passing a &() pointer. This will trigger UB.
 
     // Lint emission and information
-    pub lint_level_at: extern "C" fn(&'ast (), &'static Lint, EmissionNodeId) -> Level,
+    pub lint_level_at: extern "C" fn(&'ast (), &'static Lint, NodeId) -> Level,
     pub emit_diag: for<'a> extern "C" fn(&'ast (), &'a Diagnostic<'a, 'ast>),
 
     // Public utility
@@ -356,7 +356,7 @@ struct DriverCallbacks<'ast> {
 }
 
 impl<'ast> DriverCallbacks<'ast> {
-    fn call_lint_level_at(&self, lint: &'static Lint, node: EmissionNodeId) -> Level {
+    fn call_lint_level_at(&self, lint: &'static Lint, node: NodeId) -> Level {
         (self.lint_level_at)(self.driver_context, lint, node)
     }