SymbolPathBuffer shallow refactoring

Author: denzp

src/librustc_codegen_utils/symbol_names.rs

@@ -103,7 +103,7 @@ use rustc_mir::monomorphize::Instance;
 
 use syntax_pos::symbol::Symbol;
 
-use std::fmt::{self, Write};
+use std::fmt::Write;
 use std::mem::discriminant;
 
 pub fn provide(providers: &mut Providers) {
@@ -339,28 +339,29 @@ fn compute_symbol_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance: Instance
 //
 // To be able to work on all platforms and get *some* reasonable output, we
 // use C++ name-mangling.
-struct SymbolPathBuffer<'a, 'tcx> {
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+#[derive(Debug)]
+struct SymbolPathBuffer {
     result: String,
     temp_buf: String,
+    strict_naming: bool,
 }
 
-impl SymbolPathBuffer<'a, 'tcx> {
-    fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
+impl SymbolPathBuffer {
+    fn new(tcx: TyCtxt<'_, '_, '_>) -> Self {
         let mut result = SymbolPathBuffer {
             result: String::with_capacity(64),
             temp_buf: String::with_capacity(16),
-            tcx,
+            strict_naming: tcx.has_strict_asm_symbol_naming(),
         };
         result.result.push_str("_ZN"); // _Z == Begin name-sequence, N == nested
         result
     }
 
-    fn from_interned(symbol: ty::SymbolName, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
+    fn from_interned(symbol: ty::SymbolName, tcx: TyCtxt<'_, '_, '_>) -> Self {
         let mut result = SymbolPathBuffer {
             result: String::with_capacity(64),
             temp_buf: String::with_capacity(16),
-            tcx,
+            strict_naming: tcx.has_strict_asm_symbol_naming(),
         };
         result.result.push_str(&symbol.as_str());
         result
@@ -377,93 +378,88 @@ impl SymbolPathBuffer<'a, 'tcx> {
         let _ = write!(self.result, "17h{:016x}E", hash);
         self.result
     }
-}
 
-impl ItemPathBuffer for SymbolPathBuffer<'a, 'tcx> {
-    fn root_mode(&self) -> &RootMode {
-        const ABSOLUTE: &RootMode = &RootMode::Absolute;
-        ABSOLUTE
-    }
-
-    fn push(&mut self, text: &str) {
+    // Name sanitation. LLVM will happily accept identifiers with weird names, but
+    // gas doesn't!
+    // gas accepts the following characters in symbols: a-z, A-Z, 0-9, ., _, $
+    // NVPTX assembly has more strict naming rules than gas, so additionally, dots
+    // are replaced with '$' there.
+    fn sanitize_and_append(&mut self, s: &str) {
         self.temp_buf.clear();
-        let need_underscore = sanitize(&mut self.temp_buf, text, self.tcx);
+
+        for c in s.chars() {
+            match c {
+                // Escape these with $ sequences
+                '@' => self.temp_buf.push_str("$SP$"),
+                '*' => self.temp_buf.push_str("$BP$"),
+                '&' => self.temp_buf.push_str("$RF$"),
+                '<' => self.temp_buf.push_str("$LT$"),
+                '>' => self.temp_buf.push_str("$GT$"),
+                '(' => self.temp_buf.push_str("$LP$"),
+                ')' => self.temp_buf.push_str("$RP$"),
+                ',' => self.temp_buf.push_str("$C$"),
+
+                '-' | ':' => if self.strict_naming {
+                    // NVPTX doesn't support these characters in symbol names.
+                    self.temp_buf.push('$')
+                }
+                else {
+                    // '.' doesn't occur in types and functions, so reuse it
+                    // for ':' and '-'
+                    self.temp_buf.push('.')
+                },
+
+                '.' => if self.strict_naming {
+                    self.temp_buf.push('$')
+                }
+                else {
+                    self.temp_buf.push('.')
+                },
+
+                // These are legal symbols
+                'a'..='z' | 'A'..='Z' | '0'..='9' | '_' | '$' => self.temp_buf.push(c),
+
+                _ => {
+                    self.temp_buf.push('$');
+                    for c in c.escape_unicode().skip(1) {
+                        match c {
+                            '{' => {}
+                            '}' => self.temp_buf.push('$'),
+                            c => self.temp_buf.push(c),
+                        }
+                    }
+                }
+            }
+        }
+
+        let need_underscore = {
+            // Underscore-qualify anything that didn't start as an ident.
+            !self.temp_buf.is_empty()
+                && self.temp_buf.as_bytes()[0] != '_' as u8
+                && !(self.temp_buf.as_bytes()[0] as char).is_xid_start()
+        };
+
         let _ = write!(
             self.result,
             "{}",
             self.temp_buf.len() + (need_underscore as usize)
         );
+
         if need_underscore {
             self.result.push('_');
         }
+
         self.result.push_str(&self.temp_buf);
     }
 }
 
-// Manual Debug implementation to omit non-Debug `tcx` field.
-impl fmt::Debug for SymbolPathBuffer<'_, '_> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("SymbolPathBuffer")
-            .field("result", &self.result)
-            .field("temp_buf", &self.temp_buf)
-            .finish()
+impl ItemPathBuffer for SymbolPathBuffer {
+    fn root_mode(&self) -> &RootMode {
+        const ABSOLUTE: &RootMode = &RootMode::Absolute;
+        ABSOLUTE
     }
-}
-
-// Name sanitation. LLVM will happily accept identifiers with weird names, but
-// gas doesn't!
-// gas accepts the following characters in symbols: a-z, A-Z, 0-9, ., _, $
-// NVPTX assembly has more strict naming rules than gas, so additionally, dots
-// are replaced with '$' there.
-//
-// returns true if an underscore must be added at the start
-pub fn sanitize(result: &mut String, s: &str, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> bool {
-    for c in s.chars() {
-        match c {
-            // Escape these with $ sequences
-            '@' => result.push_str("$SP$"),
-            '*' => result.push_str("$BP$"),
-            '&' => result.push_str("$RF$"),
-            '<' => result.push_str("$LT$"),
-            '>' => result.push_str("$GT$"),
-            '(' => result.push_str("$LP$"),
-            ')' => result.push_str("$RP$"),
-            ',' => result.push_str("$C$"),
-
-            '-' | ':' => if tcx.has_strict_asm_symbol_naming() {
-                // NVPTX doesn't support these characters in symbol names.
-                result.push('$')
-            }
-            else {
-                // '.' doesn't occur in types and functions, so reuse it
-                // for ':' and '-'
-                result.push('.')
-            },
-
-            '.' => if tcx.has_strict_asm_symbol_naming() {
-                result.push('$')
-            }
-            else {
-                result.push('.')
-            },
-
-            // These are legal symbols
-            'a'..='z' | 'A'..='Z' | '0'..='9' | '_' | '$' => result.push(c),
 
-            _ => {
-                result.push('$');
-                for c in c.escape_unicode().skip(1) {
-                    match c {
-                        '{' => {}
-                        '}' => result.push('$'),
-                        c => result.push(c),
-                    }
-                }
-            }
-        }
+    fn push(&mut self, text: &str) {
+        self.sanitize_and_append(text);
     }
-
-    // Underscore-qualify anything that didn't start as an ident.
-    !result.is_empty() && result.as_bytes()[0] != '_' as u8
-        && !(result.as_bytes()[0] as char).is_xid_start()
 }