@@ -636,6 +636,31 @@ impl str::FromStr for Language {
636636 }
637637}
638638
639+ /// A [`Name`]s mangling state.
640+ ///
641+ /// By default, the mangling of a [`Name`] is not known, but an explicit mangling state can be set
642+ /// for Names that are guaranteed to be unmangled.
643+ #[ cfg_attr(
644+ feature = "serde" ,
645+ derive( Serialize , Deserialize ) ,
646+ serde( crate = "serde_" )
647+ ) ]
648+ #[ derive( Clone , Copy , Debug , Eq , Hash , Ord , PartialEq , PartialOrd ) ]
649+ pub enum NameMangling {
650+ /// The [`Name`] is definitely mangled.
651+ Mangled ,
652+ /// The [`Name`] is not mangled.
653+ Unmangled ,
654+ /// The mangling of the [`Name`] is not known.
655+ Unknown ,
656+ }
657+
658+ impl Default for NameMangling {
659+ fn default ( ) -> Self {
660+ NameMangling :: Unknown
661+ }
662+ }
663+
639664/// The name of a potentially mangled symbol.
640665///
641666/// Debugging information often only contains mangled names in their symbol and debug information
@@ -656,16 +681,17 @@ impl str::FromStr for Language {
656681/// ```
657682/// use symbolic_common::Name;
658683///
659- /// let name = Name::new ("_ZN3foo3barEv");
684+ /// let name = Name::from ("_ZN3foo3barEv");
660685/// assert_eq!(name.to_string(), "_ZN3foo3barEv");
661686/// ```
662687///
663- /// Create a name with a language. Alternate formatting prints the language:
688+ /// Create a name with a language and explicit mangling state.
689+ /// Alternate formatting prints the language:
664690///
665691/// ```
666- /// use symbolic_common::{Language, Name};
692+ /// use symbolic_common::{Language, Name, NameMangling };
667693///
668- /// let name = Name::with_language ("_ZN3foo3barEv", Language::Cpp);
694+ /// let name = Name::new ("_ZN3foo3barEv", NameMangling::Mangled , Language::Cpp);
669695/// assert_eq!(format!("{:#}", name), "_ZN3foo3barEv [C++]");
670696/// ```
671697///
@@ -679,52 +705,34 @@ impl str::FromStr for Language {
679705pub struct Name < ' a > {
680706 string : Cow < ' a , str > ,
681707 lang : Language ,
708+ #[ cfg_attr( feature = "serde" , serde( default ) ) ]
709+ mangling : NameMangling ,
682710}
683711
684712impl < ' a > Name < ' a > {
685- /// Constructs a new mangled name.
686- ///
687- /// The language of this name is `Language::Unknown`.
713+ /// Constructs a new Name with given mangling and language.
688714///
689- /// # Example
715+ /// In case both the mangling state and the language are unknown, a simpler alternative to use
716+ /// is [`Name::from`].
690717///
691- /// ```
692- /// use symbolic_common::Name;
693- ///
694- /// let name = Name::new("_ZN3foo3barEv");
695- /// assert_eq!(name.to_string(), "_ZN3foo3barEv");
696- /// ```
697- #[ inline]
698- pub fn new < S > ( string : S ) -> Self
699- where
700- S : Into < Cow < ' a , str > > ,
701- {
702- Name {
703- string : string. into ( ) ,
704- lang : Language :: Unknown ,
705- }
706- }
707-
708- /// Constructs a new mangled name with a known [`Language`].
709718///
710719/// # Example
711720///
712721/// ```
713- /// use symbolic_common::{Language, Name};
722+ /// use symbolic_common::{Language, Name, NameMangling };
714723///
715- /// let name = Name::with_language ("_ZN3foo3barEv", Language::Cpp);
724+ /// let name = Name::new ("_ZN3foo3barEv", NameMangling::Mangled , Language::Cpp);
716725/// assert_eq!(format!("{:#}", name), "_ZN3foo3barEv [C++]");
717726/// ```
718- ///
719- /// [`Language`]: enum.Language.html
720727#[ inline]
721- pub fn with_language < S > ( string : S , lang : Language ) -> Self
728+ pub fn new < S > ( string : S , mangling : NameMangling , lang : Language ) -> Self
722729 where
723730 S : Into < Cow < ' a , str > > ,
724731 {
725732 Name {
726733 string : string. into ( ) ,
727734 lang,
735+ mangling,
728736 }
729737 }
730738
@@ -733,24 +741,30 @@ impl<'a> Name<'a> {
733741/// # Example
734742///
735743/// ```
736- /// use symbolic_common::Name;
744+ /// use symbolic_common::{Language, Name, NameMangling} ;
737745///
738- /// let name = Name::new("_ZN3foo3barEv");
746+ /// let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp );
739747/// assert_eq!(name.as_str(), "_ZN3foo3barEv");
740748/// ```
741749///
742750/// This is also available as an `AsRef<str>` implementation:
743751///
744752/// ```
745- /// use symbolic_common::Name;
753+ /// use symbolic_common::{Language, Name, NameMangling} ;
746754///
747- /// let name = Name::new("_ZN3foo3barEv");
755+ /// let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp );
748756/// assert_eq!(name.as_ref(), "_ZN3foo3barEv");
749757/// ```
750758pub fn as_str ( & self ) -> & str {
751759 & self . string
752760 }
753761
762+ /// Set the `Name`'s language.
763+ pub fn set_language ( & mut self , language : Language ) -> & mut Self {
764+ self . lang = language;
765+ self
766+ }
767+
754768 /// The language of the mangled symbol.
755769///
756770/// If the language is not declared in the source, this returns `Language::Unknown`. The
@@ -760,37 +774,57 @@ impl<'a> Name<'a> {
760774/// # Example
761775///
762776/// ```
763- /// use symbolic_common::{Language, Name};
777+ /// use symbolic_common::{Language, Name, NameMangling };
764778///
765- /// let name = Name::new("_ZN3foo3barEv");
766- /// assert_eq!(name.language(), Language::Unknown );
779+ /// let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp );
780+ /// assert_eq!(name.language(), Language::Cpp );
767781/// ```
768782pub fn language ( & self ) -> Language {
769783 self . lang
770784 }
771785
772- /// Converts this name into a `Cow`, dropping the language.
786+ /// Set the `Name`'s mangling state.
787+ pub fn set_mangling ( & mut self , mangling : NameMangling ) -> & mut Self {
788+ self . mangling = mangling;
789+ self
790+ }
791+
792+ /// Returns the `Name`'s mangling state.
793+ ///
794+ /// # Example
795+ ///
796+ /// ```
797+ /// use symbolic_common::{Language, Name, NameMangling};
798+ ///
799+ /// let unmangled = Name::new("foo::bar", NameMangling::Unmangled, Language::Unknown);
800+ /// assert_eq!(unmangled.mangling(), NameMangling::Unmangled);
801+ /// ```
802+ pub fn mangling ( & self ) -> NameMangling {
803+ self . mangling
804+ }
805+
806+ /// Converts this name into a [`Cow`].
773807///
774808/// # Example
775809///
776810/// ```
777811/// use symbolic_common::Name;
778812///
779- /// let name = Name::new ("_ZN3foo3barEv");
813+ /// let name = Name::from ("_ZN3foo3barEv");
780814/// assert_eq!(name.into_cow(), "_ZN3foo3barEv");
781815/// ```
782816pub fn into_cow ( self ) -> Cow < ' a , str > {
783817 self . string
784818 }
785819
786- /// Converts this name into a `String`, dropping the language .
820+ /// Converts this name into a [ `String`] .
787821///
788822/// # Example
789823///
790824/// ```
791825/// use symbolic_common::Name;
792826///
793- /// let name = Name::new ("_ZN3foo3barEv");
827+ /// let name = Name::from ("_ZN3foo3barEv");
794828/// assert_eq!(name.into_string(), "_ZN3foo3barEv");
795829/// ```
796830pub fn into_string ( self ) -> String {
@@ -815,7 +849,7 @@ where
815849 S : Into < Cow < ' a , str > > ,
816850{
817851 fn from ( string : S ) -> Self {
818- Self :: new ( string)
852+ Self :: new ( string, NameMangling :: Unknown , Language :: Unknown )
819853 }
820854}
821855
0 commit comments