Use published version of rcc; rcc -> saltwater

Author: jyn514

Cargo.lock

@@ -58,6 +58,8 @@ regex = { version = "1.0", default-features = false , features = [ "std", "unico
 which = { version = "3.0", optional = true, default-features = false }
 shlex = "0.1"
 rustc-hash = "1.0.1"
+saltwater = { version = "0.10", default-features = false }
+
 # New validation in 0.3.6 breaks bindgen-integration:
 # https://github.com/alexcrichton/proc-macro2/commit/489c642.
 proc-macro2 = { version = "1", default-features = false }
@@ -70,11 +72,6 @@ version = "0.7"
 optional = true
 version = "0.4"
 
-[dependencies.rcc]
-git = "https://github.com/jyn514/rcc/"
-branch = "bindgen"
-default-features = false
-
 [features]
 default = ["logging", "clap", "runtime", "which-rustfmt"]
 logging = ["env_logger", "log"]

Cargo.toml

@@ -705,11 +705,11 @@ impl Cursor {
         RawTokens::new(self)
     }
 
-    /// Gets the tokens that correspond to that cursor as `rcc` tokens.
-    pub fn rcc_tokens(self) -> Vec<rcc::Locatable<rcc::Token>> {
+    /// Gets the tokens that correspond to that cursor as `saltwater` tokens.
+    pub fn swcc_tokens(self) -> Vec<saltwater::Locatable<saltwater::Token>> {
         self.tokens()
             .iter()
-            .filter_map(|token| token.as_rcc_token())
+            .filter_map(|token| token.as_swcc_token())
             .collect()
     }
 
@@ -804,12 +804,12 @@ impl ClangToken {
         c_str.to_bytes()
     }
 
-    /// Converts a ClangToken to an `rcc` token if possible.
-    pub fn as_rcc_token(&self) -> Option<rcc::Locatable<rcc::Token>> {
-        use rcc::{Files, Lexer, Literal, Token};
+    /// Converts a ClangToken to an `saltwater` token if possible.
+    pub fn as_swcc_token(&self) -> Option<saltwater::Locatable<saltwater::Token>> {
+        use saltwater::{Files, Lexer, Literal, Token};
 
         match self.kind {
-            // `rcc` does not have a comment token
+            // `saltwater` does not have a comment token
             CXToken_Comment => return None,
             CXToken_Punctuation |
             CXToken_Literal |
@@ -819,8 +819,8 @@ impl ClangToken {
                 let mut files = Files::new();
                 let id = files.add("", "".into());
                 let mut lexer = Lexer::new(id, spelling, false);
-                let mut token = lexer.next().unwrap().expect("rcc failed to parse clang token");
-                // rcc generates null-terminated string immediately,
+                let mut token = lexer.next().unwrap().expect("saltwater failed to parse clang token");
+                // saltwater generates null-terminated string immediately,
                 // but bindgen only adds the null-terminator during codegen.
                 if let Token::Literal(Literal::Str(ref mut string)) = &mut token.data {
                     assert_eq!(string.pop(), Some(b'\0'));

src/clang.rs

@@ -26,7 +26,7 @@ use crate::BindgenOptions;
 use crate::{Entry, HashMap, HashSet};
 use clang_sys;
 use proc_macro2::{Ident, Span};
-use rcc::InternedStr;
+use saltwater::InternedStr;
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::collections::HashMap as StdHashMap;
@@ -351,8 +351,8 @@ pub struct BindgenContext {
     /// hard errors while parsing duplicated macros, as well to allow macro
     /// expression parsing.
     ///
-    /// This needs to be an std::HashMap because the rcc API requires it.
-    parsed_macros: StdHashMap<InternedStr, rcc::Definition>,
+    /// This needs to be an std::HashMap because the saltwater API requires it.
+    parsed_macros: StdHashMap<InternedStr, saltwater::Definition>,
 
     /// The active replacements collected from replaces="xxx" annotations.
     replacements: HashMap<Vec<String>, ItemId>,
@@ -2043,7 +2043,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     /// Get the currently parsed macros.
     pub fn parsed_macros(
         &self,
-    ) -> &StdHashMap<InternedStr, rcc::Definition> {
+    ) -> &StdHashMap<InternedStr, saltwater::Definition> {
         debug_assert!(!self.in_codegen_phase());
         &self.parsed_macros
     }
@@ -2052,9 +2052,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     pub fn note_parsed_macro(
         &mut self,
         id: InternedStr,
-        value: rcc::Literal,
+        value: saltwater::Literal,
     ) {
-        self.parsed_macros.insert(id, rcc::Definition::Object(vec![rcc::Token::Literal(value)]));
+        self.parsed_macros.insert(id, saltwater::Definition::Object(vec![saltwater::Token::Literal(value)]));
     }
 
     /// Are we in the codegen phase?

src/ir/context.rs

@@ -14,7 +14,7 @@ use crate::parse::{
 };
 use std::io;
 use std::collections::HashMap;
-use rcc::{InternedStr, Literal};
+use saltwater::{InternedStr, Literal};
 
 /// The type for a constant variable.
 #[derive(Debug)]
@@ -245,7 +245,7 @@ impl ClangSubItemParser for Var {
                 let parse_int = |value| {
                     let kind = ctx
                         .parse_callbacks()
-                        .and_then(|c| c.int_macro(rcc::get_str!(id), value))
+                        .and_then(|c| c.int_macro(saltwater::get_str!(id), value))
                         .unwrap_or_else(|| {
                             default_macro_constant_type(value)
                         });
@@ -267,7 +267,7 @@ impl ClangSubItemParser for Var {
                             ctx,
                         );
                         if let Some(callbacks) = ctx.parse_callbacks() {
-                            callbacks.str_macro(rcc::get_str!(id), &val);
+                            callbacks.str_macro(saltwater::get_str!(id), &val);
                         }
                         (TypeKind::Pointer(char_ty), VarType::String(val))
                     }
@@ -377,10 +377,10 @@ fn parse_macro(
     ctx: &BindgenContext,
     tokens: &[ClangToken],
 ) -> Option<(InternedStr, Literal)> {
-    use rcc::Token;
+    use saltwater::Token;
 
-    let mut rcc_tokens = tokens.iter().filter_map(ClangToken::as_rcc_token);
-    let ident_str = match rcc_tokens.next()?.data {
+    let mut swcc_tokens = tokens.iter().filter_map(ClangToken::as_swcc_token);
+    let ident_str = match swcc_tokens.next()?.data {
         Token::Id(id) => id,
         _ => return None,
     };
@@ -389,8 +389,8 @@ fn parse_macro(
     }
     let parsed_macros = ctx.parsed_macros();
 
-    // TODO: remove this clone (will need changes in rcc)
-    if let Some(literal) = rcc_expr(rcc_tokens.clone(), &parsed_macros) {
+    // TODO: remove this clone (will need changes in saltwater)
+    if let Some(literal) = swcc_expr(swcc_tokens.clone(), &parsed_macros) {
         return Some((ident_str, literal));
     }
 
@@ -400,27 +400,27 @@ fn parse_macro(
     // See:
     //   https://bugs.llvm.org//show_bug.cgi?id=9069
     //   https://reviews.llvm.org/D26446
-    let tokens = tokens[1..tokens.len() - 1].iter().filter_map(ClangToken::as_rcc_token);
-    if let Some(literal) = rcc_expr(tokens, &parsed_macros) {
+    let tokens = tokens[1..tokens.len() - 1].iter().filter_map(ClangToken::as_swcc_token);
+    if let Some(literal) = swcc_expr(tokens, &parsed_macros) {
         Some((ident_str, literal))
     } else {
         None
     }
 }
 
-fn rcc_expr(rcc_tokens: impl Iterator<Item = rcc::Locatable<rcc::Token>>, definitions: &HashMap<InternedStr, rcc::Definition>) -> Option<Literal> {
-    use rcc::PreProcessor;
+fn swcc_expr(swcc_tokens: impl Iterator<Item = saltwater::Locatable<saltwater::Token>>, definitions: &HashMap<InternedStr, saltwater::Definition>) -> Option<Literal> {
+    use saltwater::PreProcessor;
 
-    let mut rcc_tokens = rcc_tokens.peekable();
-    let location = rcc_tokens.peek()?.location;
-    PreProcessor::cpp_expr(definitions, rcc_tokens, location).ok()?.const_fold().ok()?.into_literal().ok()
+    let mut swcc_tokens = swcc_tokens.peekable();
+    let location = swcc_tokens.peek()?.location;
+    PreProcessor::cpp_expr(definitions, swcc_tokens, location).ok()?.const_fold().ok()?.into_literal().ok()
 }
 
 fn parse_int_literal_tokens(cursor: &clang::Cursor) -> Option<i64> {
-    let rcc_tokens = cursor.rcc_tokens().into_iter();
+    let swcc_tokens = cursor.swcc_tokens().into_iter();
 
     // TODO(emilio): We can try to parse other kinds of literals.
-    match rcc_expr(rcc_tokens, &HashMap::new()) {
+    match swcc_expr(swcc_tokens, &HashMap::new()) {
         Some(Literal::Int(i)) => Some(i),
         Some(Literal::UnsignedInt(u)) => Some(u as i64),
         _ => None,