Rename original_name -> cpp_name.

engine/src/conversion/analysis/ctypes.rs

@@ -34,7 +34,7 @@ pub(crate) fn append_ctype_information(apis: &mut Vec<Api<FnAnalysis>>) {
     for (id, tn) in ctypes {
         apis.push(Api {
             name: QualifiedName::new(&Namespace::new(), id),
-            original_name: None,
+            cpp_name: None,
             deps: HashSet::new(),
             detail: ApiDetail::CType { typename: tn },
         });

engine/src/conversion/analysis/fun/mod.rs

@@ -210,11 +210,8 @@ impl<'a> FnAnalyzer<'a> {
             },
             ApiDetail::StringConstructor => ApiDetail::StringConstructor,
             ApiDetail::Function { fun, analysis: _ } => {
-                let analysis = self.analyze_foreign_fn(
-                    &api.name.get_namespace(),
-                    &fun,
-                    api.original_name.clone(),
-                )?;
+                let analysis =
+                    self.analyze_foreign_fn(&api.name.get_namespace(), &fun, api.cpp_name.clone())?;
                 match analysis {
                     None => return Ok(None),
                     Some(FnAnalysisResult(analysis, id, fn_deps)) => {
@@ -234,7 +231,7 @@ impl<'a> FnAnalyzer<'a> {
         };
         Ok(Some(Api {
             name: QualifiedName::new(api.name.get_namespace(), new_id),
-            original_name: api.original_name,
+            cpp_name: api.cpp_name,
             deps: new_deps,
             detail: api_detail,
         }))
@@ -302,7 +299,7 @@ impl<'a> FnAnalyzer<'a> {
         &mut self,
         ns: &Namespace,
         func_information: &FuncToConvert,
-        original_name: Option<String>,
+        cpp_name: Option<String>,
     ) -> Result<Option<FnAnalysisResult>, ConvertErrorWithContext> {
         let fun = &func_information.item;
         let virtual_this = &func_information.virtual_this_type;
@@ -315,7 +312,7 @@ impl<'a> FnAnalyzer<'a> {
         if initial_rust_name.ends_with("_destructor") {
             return Ok(None);
         }
-        let diagnostic_display_name = original_name.as_ref().unwrap_or(&initial_rust_name);
+        let diagnostic_display_name = cpp_name.as_ref().unwrap_or(&initial_rust_name);
 
         // Now let's analyze all the parameters.
         // See if any have annotations which our fork of bindgen has craftily inserted...
@@ -354,7 +351,7 @@ impl<'a> FnAnalyzer<'a> {
         // End of parameter processing.
         // Work out naming, part one.
         // The C++ call name will always be whatever bindgen tells us.
-        let cpp_call_name = original_name
+        let cpp_call_name = cpp_name
             .clone()
             .unwrap_or_else(|| initial_rust_name.clone());
         // The Rust name... it's more complicated.
@@ -363,21 +360,21 @@ impl<'a> FnAnalyzer<'a> {
         // If the former, we respect that mangling. If the latter, we don't,
         // because we'll add our own overload counting mangling later.
         // Cases:
-        //   function, IRN=foo,    ON=<none>                    output: foo    case 1
-        //   function, IRN=move_,  ON=move   (keyword problem)  output: move_  case 2
-        //   function, IRN=foo1,   ON=foo    (overload)         output: foo    case 3
-        //   method,   IRN=A_foo,  ON=foo                       output: foo    case 4
-        //   method,   IRN=A_move, ON=move   (keyword problem)  output: move_  case 5
-        //   method,   IRN=A_foo1, ON=foo    (overload)         output: foo    case 6
-        let ideal_rust_name = match original_name {
+        //   function, IRN=foo,    CN=<none>                    output: foo    case 1
+        //   function, IRN=move_,  CN=move   (keyword problem)  output: move_  case 2
+        //   function, IRN=foo1,   CN=foo    (overload)         output: foo    case 3
+        //   method,   IRN=A_foo,  CN=foo                       output: foo    case 4
+        //   method,   IRN=A_move, CN=move   (keyword problem)  output: move_  case 5
+        //   method,   IRN=A_foo1, CN=foo    (overload)         output: foo    case 6
+        let ideal_rust_name = match cpp_name {
             None => initial_rust_name, // case 1
-            Some(original_name) => {
+            Some(cpp_name) => {
                 if initial_rust_name.ends_with('_') {
                     initial_rust_name // case 2
-                } else if validate_ident_ok_for_rust(&original_name).is_err() {
-                    format!("{}_", original_name) // case 5
+                } else if validate_ident_ok_for_rust(&cpp_name).is_err() {
+                    format!("{}_", cpp_name) // case 5
                 } else {
-                    original_name // cases 3, 4, 6
+                    cpp_name // cases 3, 4, 6
                 }
             }
         };

engine/src/conversion/analysis/name_check.rs

@@ -33,7 +33,7 @@ pub(crate) fn check_names(apis: Vec<Api<FnAnalysis>>) -> Vec<Api<FnAnalysis>> {
         | ApiDetail::Enum { .. }
         | ApiDetail::Struct { .. } => {
             let cxx_name = api
-                .original_name
+                .cpp_name
                 .as_ref()
                 .map(|s|
                     QualifiedName::new_from_cpp_name(&s)

engine/src/conversion/analysis/pod/mod.rs

@@ -145,7 +145,7 @@ fn analyze_pod_api(
     };
     Ok(Api {
         name: api.name,
-        original_name: api.original_name,
+        cpp_name: api.cpp_name,
         deps: new_deps,
         detail: api_detail,
     })

engine/src/conversion/analysis/remove_ignored.rs

@@ -70,7 +70,7 @@ fn create_ignore_item(api: Api<FnAnalysis>, err: ConvertError) -> Api<FnAnalysis
     let id = api.name().get_final_ident();
     Api {
         name: api.name(),
-        original_name: api.original_name,
+        cpp_name: api.cpp_name,
         deps: HashSet::new(),
         detail: ApiDetail::IgnoredItem {
             err,

engine/src/conversion/analysis/tdef.rs

@@ -52,7 +52,7 @@ pub(crate) fn convert_typedef_targets(
         .into_iter()
         .filter_map(|api| {
             let name = api.name();
-            let original_name = api.original_name;
+            let cpp_name = api.cpp_name;
             let ns = name.get_namespace();
             let mut newdeps = api.deps;
             let detail = match api.detail {
@@ -93,7 +93,7 @@ pub(crate) fn convert_typedef_targets(
             detail.map(|detail| Api {
                 detail,
                 name,
-                original_name,
+                cpp_name,
                 deps: newdeps,
             })
         })

engine/src/conversion/analysis/type_converter.rs

@@ -393,7 +393,7 @@ impl<'a> TypeConverter<'a> {
                     name: name.clone(),
                     // This is a synthesized type that isn't nested within anything else,
                     // so it doesn't have an orignal_name.
-                    original_name: None,
+                    cpp_name: None,
                     deps: HashSet::new(),
                     detail: crate::conversion::api::ApiDetail::ConcreteType {
                         rs_definition: Box::new(rs_definition.clone()),
@@ -523,7 +523,7 @@ pub(crate) fn add_analysis<A: AnalysisPhase>(api: UnanalyzedApi) -> Api<A> {
     };
     Api {
         name: api.name,
-        original_name: api.original_name,
+        cpp_name: api.cpp_name,
         deps: api.deps,
         detail: new_detail,
     }

engine/src/conversion/api.rs

@@ -144,8 +144,10 @@ pub(crate) enum ApiDetail<T: AnalysisPhase> {
 /// because sometimes we pass on the `bindgen` output directly in the
 /// Rust codegen output.
 pub(crate) struct Api<T: AnalysisPhase> {
+    /// The name by which we refer to this within Rust.
     pub(crate) name: QualifiedName,
-    pub(crate) original_name: Option<String>,
+    /// The C++ name, if it's different.
+    pub(crate) cpp_name: Option<String>,
     /// Any dependencies of this API, such that during garbage collection
     /// we can ensure to keep them.
     pub(crate) deps: HashSet<QualifiedName>,

engine/src/conversion/codegen_cpp/function_wrapper_cpp.rs

@@ -18,37 +18,31 @@ use crate::conversion::{
 };
 use crate::known_types::type_lacks_copy_constructor;
 
-use super::type_to_cpp::{type_to_cpp, OriginalNameMap};
+use super::type_to_cpp::{type_to_cpp, CppNameMap};
 
 impl TypeConversionPolicy {
     pub(super) fn unconverted_type(
         &self,
-        original_name_map: &OriginalNameMap,
+        cpp_name_map: &CppNameMap,
     ) -> Result<String, ConvertError> {
         match self.cpp_conversion {
-            CppConversionType::FromUniquePtrToValue => self.wrapped_type(original_name_map),
-            _ => self.unwrapped_type_as_string(original_name_map),
+            CppConversionType::FromUniquePtrToValue => self.wrapped_type(cpp_name_map),
+            _ => self.unwrapped_type_as_string(cpp_name_map),
         }
     }
 
-    pub(super) fn converted_type(
-        &self,
-        original_name_map: &OriginalNameMap,
-    ) -> Result<String, ConvertError> {
+    pub(super) fn converted_type(&self, cpp_name_map: &CppNameMap) -> Result<String, ConvertError> {
         match self.cpp_conversion {
-            CppConversionType::FromValueToUniquePtr => self.wrapped_type(original_name_map),
-            _ => self.unwrapped_type_as_string(original_name_map),
+            CppConversionType::FromValueToUniquePtr => self.wrapped_type(cpp_name_map),
+            _ => self.unwrapped_type_as_string(cpp_name_map),
         }
     }
 
-    fn unwrapped_type_as_string(
-        &self,
-        original_name_map: &OriginalNameMap,
-    ) -> Result<String, ConvertError> {
-        type_to_cpp(&self.unwrapped_type, original_name_map)
+    fn unwrapped_type_as_string(&self, cpp_name_map: &CppNameMap) -> Result<String, ConvertError> {
+        type_to_cpp(&self.unwrapped_type, cpp_name_map)
     }
 
-    fn wrapped_type(&self, original_name_map: &OriginalNameMap) -> Result<String, ConvertError> {
+    fn wrapped_type(&self, original_name_map: &CppNameMap) -> Result<String, ConvertError> {
         Ok(format!(
             "std::unique_ptr<{}>",
             self.unwrapped_type_as_string(original_name_map)?
@@ -58,7 +52,7 @@ impl TypeConversionPolicy {
     pub(super) fn cpp_conversion(
         &self,
         var_name: &str,
-        original_name_map: &OriginalNameMap,
+        cpp_name_map: &CppNameMap,
     ) -> Result<String, ConvertError> {
         Ok(match self.cpp_conversion {
             CppConversionType::None => {
@@ -71,7 +65,7 @@ impl TypeConversionPolicy {
             CppConversionType::FromUniquePtrToValue => format!("std::move(*{})", var_name),
             CppConversionType::FromValueToUniquePtr => format!(
                 "std::make_unique<{}>({})",
-                self.unconverted_type(original_name_map)?,
+                self.unconverted_type(cpp_name_map)?,
                 var_name
             ),
         })

engine/src/conversion/codegen_cpp/mod.rs

@@ -20,7 +20,7 @@ use autocxx_parser::IncludeCppConfig;
 use itertools::Itertools;
 use std::collections::HashSet;
 use syn::Type;
-use type_to_cpp::{original_name_map_from_apis, type_to_cpp, OriginalNameMap};
+use type_to_cpp::{original_name_map_from_apis, type_to_cpp, CppNameMap};
 
 use super::{
     analysis::fun::{
@@ -82,7 +82,7 @@ struct AdditionalFunction {
 pub(crate) struct CppCodeGenerator<'a> {
     additional_functions: Vec<AdditionalFunction>,
     inclusions: String,
-    original_name_map: OriginalNameMap,
+    original_name_map: CppNameMap,
     config: &'a IncludeCppConfig,
 }
 
@@ -99,7 +99,7 @@ impl<'a> CppCodeGenerator<'a> {
 
     fn new(
         inclusions: String,
-        original_name_map: OriginalNameMap,
+        original_name_map: CppNameMap,
         config: &'a IncludeCppConfig,
     ) -> Self {
         CppCodeGenerator {

engine/src/conversion/codegen_cpp/type_to_cpp.rs

@@ -25,17 +25,17 @@ use syn::{Token, Type};
 /// Map from QualifiedName to original C++ name. Original C++ name does not
 /// include the namespace; this can be assumed to be the same as the namespace
 /// in the QualifiedName.
-pub(crate) type OriginalNameMap = HashMap<QualifiedName, String>;
+pub(crate) type CppNameMap = HashMap<QualifiedName, String>;
 
-pub(crate) fn original_name_map_from_apis<T: AnalysisPhase>(apis: &[Api<T>]) -> OriginalNameMap {
+pub(crate) fn original_name_map_from_apis<T: AnalysisPhase>(apis: &[Api<T>]) -> CppNameMap {
     apis.iter()
         .filter_map(|api| {
             if let Api {
-                original_name: Some(original_name),
+                cpp_name: Some(cpp_name),
                 ..
             } = api
             {
-                Some((api.name(), original_name.clone()))
+                Some((api.name(), cpp_name.clone()))
             } else {
                 None
             }
@@ -45,36 +45,33 @@ pub(crate) fn original_name_map_from_apis<T: AnalysisPhase>(apis: &[Api<T>]) ->
 
 pub(crate) fn namespaced_name_using_original_name_map(
     qual_name: &QualifiedName,
-    original_name_map: &OriginalNameMap,
+    original_name_map: &CppNameMap,
 ) -> String {
-    if let Some(original_name) = original_name_map.get(&qual_name) {
+    if let Some(cpp_name) = original_name_map.get(&qual_name) {
         qual_name
             .get_namespace()
             .iter()
-            .chain(once(original_name))
+            .chain(once(cpp_name))
             .join("::")
     } else {
         qual_name.to_cpp_name()
     }
 }
 
-pub(crate) fn type_to_cpp(
-    ty: &Type,
-    original_name_map: &OriginalNameMap,
-) -> Result<String, ConvertError> {
+pub(crate) fn type_to_cpp(ty: &Type, cpp_name_map: &CppNameMap) -> Result<String, ConvertError> {
     match ty {
         Type::Path(typ) => {
             // If this is a std::unique_ptr we do need to pass
             // its argument through.
             let qual_name = QualifiedName::from_type_path(typ);
-            let root = namespaced_name_using_original_name_map(&qual_name, original_name_map);
+            let root = namespaced_name_using_original_name_map(&qual_name, cpp_name_map);
             if root == "Pin" {
                 // Strip all Pins from type names when describing them in C++.
                 let inner_type = &typ.path.segments.last().unwrap().arguments;
                 if let syn::PathArguments::AngleBracketed(ab) = inner_type {
                     let inner_type = ab.args.iter().next().unwrap();
                     if let syn::GenericArgument::Type(gat) = inner_type {
-                        return type_to_cpp(gat, original_name_map);
+                        return type_to_cpp(gat, cpp_name_map);
                     }
                 }
                 panic!("Pin<...> didn't contain the inner types we expected");
@@ -85,7 +82,7 @@ pub(crate) fn type_to_cpp(
                         .args
                         .iter()
                         .map(|x| match x {
-                            syn::GenericArgument::Type(gat) => type_to_cpp(gat, original_name_map),
+                            syn::GenericArgument::Type(gat) => type_to_cpp(gat, cpp_name_map),
                             _ => Ok("".to_string()),
                         })
                         .collect();
@@ -101,12 +98,12 @@ pub(crate) fn type_to_cpp(
         Type::Reference(typr) => Ok(format!(
             "{}{}&",
             get_mut_string(&typr.mutability),
-            type_to_cpp(typr.elem.as_ref(), original_name_map)?
+            type_to_cpp(typr.elem.as_ref(), cpp_name_map)?
         )),
         Type::Ptr(typp) => Ok(format!(
             "{}{}*",
             get_mut_string(&typp.mutability),
-            type_to_cpp(typp.elem.as_ref(), original_name_map)?
+            type_to_cpp(typp.elem.as_ref(), cpp_name_map)?
         )),
         Type::Array(_)
         | Type::BareFn(_)

engine/src/conversion/codegen_rs/mod.rs

@@ -40,7 +40,7 @@ use self::{
 };
 
 use super::codegen_cpp::type_to_cpp::{
-    namespaced_name_using_original_name_map, original_name_map_from_apis, OriginalNameMap,
+    namespaced_name_using_original_name_map, original_name_map_from_apis, CppNameMap,
 };
 use super::{
     analysis::fun::FnAnalysis,
@@ -120,7 +120,7 @@ fn remove_nones<T>(input: Vec<Option<T>>) -> Vec<T> {
 pub(crate) struct RsCodeGenerator<'a> {
     include_list: &'a [String],
     bindgen_mod: ItemMod,
-    original_name_map: OriginalNameMap,
+    original_name_map: CppNameMap,
     config: &'a IncludeCppConfig,
 }
 
@@ -567,10 +567,10 @@ impl<'a> RsCodeGenerator<'a> {
         let id = name.get_final_ident();
         let mut ns_components: Vec<_> = ns.iter().cloned().collect();
         let mut cxx_name = None;
-        if let Some(original_name) = self.original_name_map.get(name) {
-            let original_name = QualifiedName::new_from_cpp_name(original_name);
-            cxx_name = Some(original_name.get_final_item().to_string());
-            ns_components.extend(original_name.ns_segment_iter().cloned());
+        if let Some(cpp_name) = self.original_name_map.get(name) {
+            let cpp_name = QualifiedName::new_from_cpp_name(cpp_name);
+            cxx_name = Some(cpp_name.get_final_item().to_string());
+            ns_components.extend(cpp_name.ns_segment_iter().cloned());
         };
 
         let mut for_extern_c_ts = if !ns_components.is_empty() {

engine/src/conversion/error_reporter.rs

@@ -92,7 +92,7 @@ pub(crate) fn convert_item_apis<F, A, B>(
 fn ignored_item<A: AnalysisPhase>(ns: &Namespace, ctx: ErrorContext, err: ConvertError) -> Api<A> {
     Api {
         name: QualifiedName::new(ns, ctx.get_id().clone()),
-        original_name: None,
+        cpp_name: None,
         deps: HashSet::new(),
         detail: ApiDetail::IgnoredItem { err, ctx },
     }