Add from docs for tools

Author: TimTheBig

src/tools/clippy/clippy_lints/src/attrs/mixed_attributes_style.rs

@@ -15,6 +15,10 @@ enum SimpleAttrKind {
 }
 
 impl From<&AttrKind> for SimpleAttrKind {
+    /// Convert an `AttrKind` to a `SimpleAttrKind`, if it's a `DocComment` then `Doc` is returned with no conversion.
+    ///
+    /// ## Cost
+    /// If `AttrKind` is `DocComment` it's free, however if it's `Normal` their is heep allocation
     fn from(value: &AttrKind) -> Self {
         match value {
             AttrKind::Normal(attr) => {

src/tools/miri/src/concurrency/thread.rs

@@ -80,6 +80,7 @@ impl Idx for ThreadId {
 }
 
 impl From<ThreadId> for u64 {
+    /// Return inner `u32` converted to `u64`
     fn from(t: ThreadId) -> Self {
         t.0.into()
     }

src/tools/miri/src/concurrency/vector_clock.rs

@@ -34,6 +34,7 @@ impl Idx for VectorIdx {
 }
 
 impl From<u32> for VectorIdx {
+    /// Create new `VectorIdx` with `u32` as inner
     #[inline]
     fn from(id: u32) -> Self {
         Self(id)

src/tools/miri/src/lib.rs

@@ -74,7 +74,7 @@ extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
-// Linking `rustc_driver` pulls in the required  object code as the rest of the rustc crates are
+// Linking `rustc_driver` pulls in the required object code as the rest of the rustc crates are
 // shipped only as rmeta files.
 #[allow(unused_extern_crates)]
 extern crate rustc_driver;

src/tools/miri/src/shims/io_error.rs

@@ -14,18 +14,21 @@ pub enum IoError {
 pub use self::IoError::*;
 
 impl From<io::Error> for IoError {
+    /// Wrap `io::Error` in `HostError`
     fn from(value: io::Error) -> Self {
         IoError::HostError(value)
     }
 }
 
 impl From<io::ErrorKind> for IoError {
+    /// Convert a `io::ErrorKind` to a `io::Error` then wrap in `HostError`
     fn from(value: io::ErrorKind) -> Self {
         IoError::HostError(value.into())
     }
 }
 
 impl From<Scalar> for IoError {
+    /// Wrap `Scalar` in `Raw`
     fn from(value: Scalar) -> Self {
         IoError::Raw(value)
     }

src/tools/rust-analyzer/crates/base-db/src/input.rs

@@ -173,6 +173,8 @@ pub enum LangCrateOrigin {
 }
 
 impl From<&str> for LangCrateOrigin {
+    /// Match a string slice for "alloc", "core", "proc-macro", "proc_macro", "std", "test",
+    /// mapping them to variants of the same name; if none match then it's `Other`
     fn from(s: &str) -> Self {
         match s {
             "alloc" => LangCrateOrigin::Alloc,
@@ -217,6 +219,10 @@ impl CrateDisplayName {
 }
 
 impl From<CrateName> for CrateDisplayName {
+    /// Creates a `CrateDisplayName` from `crate_name` and `crate_name.0`(inner)
+    /// 
+    /// ## Cost
+    /// This clones `CrateName`
     fn from(crate_name: CrateName) -> CrateDisplayName {
         let canonical_name = crate_name.0.clone();
         CrateDisplayName { crate_name, canonical_name }
@@ -634,6 +640,10 @@ impl Env {
 }
 
 impl From<Env> for Vec<(String, String)> {
+    /// Iterates the hash map entries collects them in to a `Vec` then sorts it.
+    ///
+    /// ## Cost
+    /// This is expensive as it `collect`s and `sort`s env
     fn from(env: Env) -> Vec<(String, String)> {
         let mut entries: Vec<_> = env.entries.into_iter().collect();
         entries.sort();

src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs

@@ -38,6 +38,7 @@ pub enum CfgExpr {
 }
 
 impl From<CfgAtom> for CfgExpr {
+    /// Wrap `CfgAtom` in `CfgExpr::Atom`
     fn from(atom: CfgAtom) -> Self {
         CfgExpr::Atom(atom)
     }

src/tools/rust-analyzer/crates/hir-def/src/attr.rs

@@ -245,6 +245,7 @@ pub enum DocExpr {
 }
 
 impl From<DocAtom> for DocExpr {
+    /// Creates `Atom` with `DocAtom`
     fn from(atom: DocAtom) -> Self {
         DocExpr::Atom(atom)
     }

src/tools/rust-analyzer/crates/hir-def/src/hir.rs

@@ -146,6 +146,7 @@ impl Literal {
 }
 
 impl From<ast::LiteralKind> for Literal {
+    /// Create a `Literal` by matching `LiteralKind`
     fn from(ast_lit_kind: ast::LiteralKind) -> Self {
         use ast::LiteralKind;
         match ast_lit_kind {

src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs

@@ -637,6 +637,8 @@ impl LiteralConstRef {
 }
 
 impl From<Literal> for LiteralConstRef {
+    /// Make a `LiteralConstRef` from `Literal`
+    /// - Note: `Char`, `Bool`, `Int`, `Uint` match, other types are not const and return a `Unknown`
     fn from(literal: Literal) -> Self {
         match literal {
             Literal::Char(c) => Self::Char(c),

src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs

@@ -37,6 +37,7 @@ pub enum ImportOrExternCrate {
 }
 
 impl From<ImportOrGlob> for ImportOrExternCrate {
+    /// Matches a `ImportOrGlob` to it's corresponding `ImportOrExternCrate` variant, of the same name
     fn from(value: ImportOrGlob) -> Self {
         match value {
             ImportOrGlob::Glob(it) => ImportOrExternCrate::Glob(it),
@@ -101,6 +102,7 @@ pub enum ImportOrDef {
 }
 
 impl From<ImportOrExternCrate> for ImportOrDef {
+    /// Matches a `ImportOrExternCrate` to it's corresponding `ImportOrDef` variant, of the same name
     fn from(value: ImportOrExternCrate) -> Self {
         match value {
             ImportOrExternCrate::Import(it) => ImportOrDef::Import(it),
@@ -111,6 +113,7 @@ impl From<ImportOrExternCrate> for ImportOrDef {
 }
 
 impl From<ImportOrGlob> for ImportOrDef {
+    /// Matches a `ImportOrGlob` to it's corresponding `ImportOrDef` variant, of the same name
     fn from(value: ImportOrGlob) -> Self {
         match value {
             ImportOrGlob::Import(it) => ImportOrDef::Import(it),

src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs

@@ -516,6 +516,11 @@ macro_rules! from_attrs {
     ( $( $var:ident($t:ty) ),+ $(,)? ) => {
         $(
             impl From<$t> for AttrOwner {
+                #[doc = concat!(
+                    "Create a `", stringify!($var), "` from a `", stringify!($t), "`",
+                    "\n\n## Cost",
+                    "This is free as it puts `", stringify!($t), "` into `", stringify!($var), "`"
+                )]
                 fn from(t: $t) -> AttrOwner {
                     AttrOwner::$var(t)
                 }
@@ -722,6 +727,10 @@ macro_rules! mod_items {
         }
 
         impl From<GenericModItem> for ModItem {
+            /// Create a `ModItem` from a `GenericModItem` variant of the same name
+            ///
+            /// ## Cost
+            /// Just a `match`
             fn from(id: GenericModItem) -> ModItem {
                 match id {
                     $(
@@ -735,20 +744,26 @@ macro_rules! mod_items {
         }
 
         impl From<GenericModItem> for AttrOwner {
+            /// Create a `AttrOwner::ModItem` with `GenericModItem` as inner
+            /// 
+            /// ## Cost
+            /// The cost is that of the `t.into()` call
             fn from(t: GenericModItem) -> AttrOwner {
                 AttrOwner::ModItem(t.into())
             }
         }
 
         $(
             impl From<FileItemTreeId<$typ>> for ModItem {
+                #[doc = concat!("Create a `ModItem<", stringify!($typ), ">` from a `FileItemTreeId<", stringify!($typ), ">` variant of the same name")]
                 fn from(id: FileItemTreeId<$typ>) -> ModItem {
                     ModItem::$typ(id)
                 }
             }
             $(
                 #[cfg_attr(ignore_fragment, $generic_params)]
                 impl From<FileItemTreeId<$typ>> for GenericModItem {
+                    #[doc = concat!("Create a `GenericModItem` from a `FileItemTreeId<", stringify!($typ), ">` variant of the same name")]
                     fn from(id: FileItemTreeId<$typ>) -> GenericModItem {
                         GenericModItem::$typ(id)
                     }
@@ -1248,6 +1263,10 @@ macro_rules! impl_froms {
     ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => {
         $(
             impl From<$t> for $e {
+                #[doc = concat!(
+                    "Create a `", stringify!($e), "` with `", stringify!($t), "` as the inner",
+                    "\n\n## Cost\n", stringify!($t), " gets move into ", stringify!($v)
+                )]
                 fn from(it: $t) -> $e {
                     $e::$v(it)
                 }
@@ -1296,6 +1315,10 @@ impl_froms!(AssocItem {
 });
 
 impl From<AssocItem> for ModItem {
+    /// Convert the `AssocItem`s inner to a `ModItem`
+    /// 
+    /// ## Cost
+    /// The cost is that of the inner items `into` call
     fn from(item: AssocItem) -> Self {
         match item {
             AssocItem::Function(it) => it.into(),

src/tools/rust-analyzer/crates/hir-def/src/lib.rs

@@ -410,18 +410,21 @@ impl PartialEq<CrateRootModuleId> for ModuleId {
 }
 
 impl From<CrateRootModuleId> for ModuleId {
+    /// Make a `ModuleId` with a krate, no block, and local_id of `ROOT`
     fn from(CrateRootModuleId { krate }: CrateRootModuleId) -> Self {
         ModuleId { krate, block: None, local_id: DefMap::ROOT }
     }
 }
 
 impl From<CrateRootModuleId> for ModuleDefId {
+    /// Make a `ModuleId` with `CrateRootModuleId` as inner
     fn from(value: CrateRootModuleId) -> Self {
         ModuleDefId::ModuleId(value.into())
     }
 }
 
 impl From<CrateId> for CrateRootModuleId {
+    /// Create a `CrateRootModuleId` with `CrateId` as inner
     fn from(krate: CrateId) -> Self {
         CrateRootModuleId { krate }
     }
@@ -564,6 +567,7 @@ impl TypeParamId {
 }
 
 impl From<TypeParamId> for TypeOrConstParamId {
+    /// Get the inner `TypeOrConstParamId` of `TypeParamId`
     fn from(it: TypeParamId) -> Self {
         it.0
     }
@@ -590,6 +594,7 @@ impl ConstParamId {
 }
 
 impl From<ConstParamId> for TypeOrConstParamId {
+    /// Get the inner `TypeOrConstParamId` of `ConstParamId`
     fn from(it: ConstParamId) -> Self {
         it.0
     }
@@ -729,6 +734,7 @@ impl_from!(
 
 // Every `DefWithBodyId` is a type owner, since bodies can contain type (e.g. `{ let it: Type = _; }`)
 impl From<DefWithBodyId> for TypeOwnerId {
+    /// Convert `DefWithBodyId` inner into `TypeOwnerId`
     fn from(value: DefWithBodyId) -> Self {
         match value {
             DefWithBodyId::FunctionId(it) => it.into(),
@@ -741,6 +747,7 @@ impl From<DefWithBodyId> for TypeOwnerId {
 }
 
 impl From<GenericDefId> for TypeOwnerId {
+    /// Convert `GenericDefId` inner into `TypeOwnerId`
     fn from(value: GenericDefId) -> Self {
         match value {
             GenericDefId::FunctionId(it) => it.into(),
@@ -896,6 +903,7 @@ pub enum DefWithBodyId {
 impl_from!(FunctionId, ConstId, StaticId, InTypeConstId for DefWithBodyId);
 
 impl From<EnumVariantId> for DefWithBodyId {
+    /// Make a `VariantId` with `EnumVariantId`, as inner
     fn from(id: EnumVariantId) -> Self {
         DefWithBodyId::VariantId(id)
     }
@@ -1008,6 +1016,7 @@ impl GenericDefId {
 }
 
 impl From<AssocItemId> for GenericDefId {
+    /// Convert `AssocItemId` inner to `GenericDefId`
     fn from(item: AssocItemId) -> Self {
         match item {
             AssocItemId::FunctionId(f) => f.into(),
@@ -1028,6 +1037,7 @@ impl InternValueTrivial for CallableDefId {}
 
 impl_from!(FunctionId, StructId, EnumVariantId for CallableDefId);
 impl From<CallableDefId> for ModuleDefId {
+    /// Match `CallableDefId` to `ModuleDefId`
     fn from(def: CallableDefId) -> ModuleDefId {
         match def {
             CallableDefId::FunctionId(f) => ModuleDefId::FunctionId(f),
@@ -1089,6 +1099,10 @@ impl_from!(
 impl TryFrom<ModuleDefId> for AttrDefId {
     type Error = ();
 
+    /// Convert the inner of `ModuleDefId` into `Ok(AttrDefId)`
+    ///
+    /// # Errors
+    /// `BuiltinType` results in `Err`
     fn try_from(value: ModuleDefId) -> Result<Self, Self::Error> {
         match value {
             ModuleDefId::ModuleId(it) => Ok(it.into()),
@@ -1107,6 +1121,7 @@ impl TryFrom<ModuleDefId> for AttrDefId {
 }
 
 impl From<ItemContainerId> for AttrDefId {
+    /// Match `ItemContainerId` to the `AttrDefId` variant of the same name
     fn from(acid: ItemContainerId) -> Self {
         match acid {
             ItemContainerId::ModuleId(mid) => AttrDefId::ModuleId(mid),
@@ -1117,6 +1132,7 @@ impl From<ItemContainerId> for AttrDefId {
     }
 }
 impl From<AssocItemId> for AttrDefId {
+    /// Match `AssocItemId` to the `AttrDefId` variant of the same name
     fn from(assoc: AssocItemId) -> Self {
         match assoc {
             AssocItemId::FunctionId(it) => AttrDefId::FunctionId(it),
@@ -1126,6 +1142,7 @@ impl From<AssocItemId> for AttrDefId {
     }
 }
 impl From<VariantId> for AttrDefId {
+    /// Convert the inner of `VariantId` into `AttrDefId`
     fn from(vid: VariantId) -> Self {
         match vid {
             VariantId::EnumVariantId(id) => id.into(),

src/tools/rust-analyzer/crates/hir-def/src/path.rs

@@ -328,6 +328,7 @@ impl GenericArgs {
 }
 
 impl From<Name> for Path {
+    /// Make a `BarePath` with a new `Interned` containing a `ModPath` using the `Name`
     fn from(name: Name) -> Path {
         Path::BarePath(Interned::new(ModPath::from_segments(PathKind::Plain, iter::once(name))))
     }

src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs

@@ -72,6 +72,11 @@ impl ConstEvalError {
 }
 
 impl From<MirLowerError> for ConstEvalError {
+    /// Convert `MirLowerError` to `ConstEvalError` by getting inner of `MirLowerError::ConstEvalError`
+    /// or wrapping it in the `MirLowerError` variant
+    ///
+    /// ## Cost
+    /// Just a `match`
     fn from(value: MirLowerError) -> Self {
         match value {
             MirLowerError::ConstEvalError(_, e) => *e,
@@ -81,6 +86,10 @@ impl From<MirLowerError> for ConstEvalError {
 }
 
 impl From<MirEvalError> for ConstEvalError {
+    /// Convert a `MirEvalError` by wrapping it in the `ConstEvalError::MirEvalError` variant
+    ///
+    /// ## Cost
+    /// Free
     fn from(value: MirEvalError) -> Self {
         ConstEvalError::MirEvalError(value)
     }

src/tools/rust-analyzer/crates/hir-ty/src/display.rs

@@ -438,6 +438,7 @@ pub enum HirDisplayError {
     FmtError,
 }
 impl From<fmt::Error> for HirDisplayError {
+    /// Ignore the `fmt::Error` and return `Self::FmtError`
     fn from(_: fmt::Error) -> Self {
         Self::FmtError
     }

src/tools/rust-analyzer/crates/hir-ty/src/layout.rs

@@ -110,6 +110,7 @@ impl fmt::Display for LayoutError {
 }
 
 impl<F> From<LayoutCalculatorError<F>> for LayoutError {
+    /// Make a `BadCalc` error from a `LayoutCalculatorError` without payload
     fn from(err: LayoutCalculatorError<F>) -> Self {
         LayoutError::BadCalc(err.without_payload())
     }