rust/crates/ra_hir/src/name.rs

use std::fmt;

use ra_syntax::{ast, SmolStr};

/// `Name` is a wrapper around string, which is used in hir for both references
/// and declarations. In theory, names should also carry hygiene info, but we are
/// not there yet!
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Name {
    text: SmolStr,
}

impl fmt::Display for Name {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.text, f)
    }
}

impl fmt::Debug for Name {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self.text, f)
    }
}

impl Name {
    /// Note: this is private to make creating name from random string hard.
    /// Hopefully, this should allow us to integrate hygiene cleaner in the
    /// future, and to switch to interned representation of names.
    fn new(text: SmolStr) -> Name {
        Name { text }
    }

    pub(crate) fn missing() -> Name {
        Name::new("[missing name]".into())
    }

    pub(crate) fn self_param() -> Name {
        Name::new("self".into())
    }

    pub(crate) fn self_type() -> Name {
        Name::new("Self".into())
    }

    pub(crate) fn tuple_field_name(idx: usize) -> Name {
        Name::new(idx.to_string().into())
    }

    // Needed for Deref
    pub(crate) fn target() -> Name {
        Name::new("Target".into())
    }

    // There's should be no way to extract a string out of `Name`: `Name` in the
    // future, `Name` will include hygiene information, and you can't encode
    // hygiene into a String.
    //
    // If you need to compare something with `Name`, compare `Name`s directly.
    //
    // If you need to render `Name` for the user, use the `Display` impl, but be
    // aware that it strips hygiene info.
    #[deprecated(note = "use to_string instead")]
    pub fn as_smolstr(&self) -> &SmolStr {
        &self.text
    }

    pub(crate) fn as_known_name(&self) -> Option<KnownName> {
        let name = match self.text.as_str() {
            "isize" => KnownName::Isize,
            "i8" => KnownName::I8,
            "i16" => KnownName::I16,
            "i32" => KnownName::I32,
            "i64" => KnownName::I64,
            "i128" => KnownName::I128,
            "usize" => KnownName::Usize,
            "u8" => KnownName::U8,
            "u16" => KnownName::U16,
            "u32" => KnownName::U32,
            "u64" => KnownName::U64,
            "u128" => KnownName::U128,
            "f32" => KnownName::F32,
            "f64" => KnownName::F64,
            "bool" => KnownName::Bool,
            "char" => KnownName::Char,
            "str" => KnownName::Str,
            "Self" => KnownName::SelfType,
            "self" => KnownName::SelfParam,
            "macro_rules" => KnownName::MacroRules,

            "std" => KnownName::Std,
            "iter" => KnownName::Iter,
            "IntoIterator" => KnownName::IntoIterator,
            "Item" => KnownName::Item,
            _ => return None,
        };
        Some(name)
    }
}

pub(crate) trait AsName {
    fn as_name(&self) -> Name;
}

impl AsName for ast::NameRef {
    fn as_name(&self) -> Name {
        let name = resolve_name(self.text());
        Name::new(name)
    }
}

impl AsName for ast::Name {
    fn as_name(&self) -> Name {
        let name = resolve_name(self.text());
        Name::new(name)
    }
}

impl<'a> AsName for ast::FieldKind<'a> {
    fn as_name(&self) -> Name {
        match self {
            ast::FieldKind::Name(nr) => nr.as_name(),
            ast::FieldKind::Index(idx) => Name::new(idx.text().clone()),
        }
    }
}

impl AsName for ra_db::Dependency {
    fn as_name(&self) -> Name {
        Name::new(self.name.clone())
    }
}

// Ideally, should be replaced with
// ```
// const ISIZE: Name = Name::new("isize")
// ```
// but const-fn is not that powerful yet.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum KnownName {
    Isize,
    I8,
    I16,
    I32,
    I64,
    I128,

    Usize,
    U8,
    U16,
    U32,
    U64,
    U128,

    F32,
    F64,

    Bool,
    Char,
    Str,

    SelfType,
    SelfParam,

    MacroRules,

    Std,
    Iter,
    IntoIterator,
    Item,
}

impl AsName for KnownName {
    fn as_name(&self) -> Name {
        let s = match self {
            KnownName::Isize => "isize",
            KnownName::I8 => "i8",
            KnownName::I16 => "i16",
            KnownName::I32 => "i32",
            KnownName::I64 => "i64",
            KnownName::I128 => "i128",
            KnownName::Usize => "usize",
            KnownName::U8 => "u8",
            KnownName::U16 => "u16",
            KnownName::U32 => "u32",
            KnownName::U64 => "u64",
            KnownName::U128 => "u128",
            KnownName::F32 => "f32",
            KnownName::F64 => "f64",
            KnownName::Bool => "bool",
            KnownName::Char => "char",
            KnownName::Str => "str",
            KnownName::SelfType => "Self",
            KnownName::SelfParam => "self",
            KnownName::MacroRules => "macro_rules",
            KnownName::Std => "std",
            KnownName::Iter => "iter",
            KnownName::IntoIterator => "IntoIterator",
            KnownName::Item => "Item",
        };
        Name::new(s.into())
    }
}

fn resolve_name(text: &SmolStr) -> SmolStr {
    let raw_start = "r#";
    if text.as_str().starts_with(raw_start) {
        SmolStr::new(&text[raw_start.len()..])
    } else {
        text.clone()
    }
}