/// `out_path` and fills it with wrapper structs/functions to allow calling the things in the AST
/// at `module` from C.
fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a>, in_dir: &str, out_dir: &str, path: &str, orig_crate: &str, module: &str, header_file: &mut File, cpp_header_file: &mut File) {
- eprintln!("Converting {}...", path);
-
let syntax = if let Some(ast) = libast.files.get(module) { ast } else { return };
assert!(syntax.shebang.is_none()); // Not sure what this is, hope we dont have one
orig_crate, &new_mod, header_file, cpp_header_file);
}
+ eprintln!("Converting {} entries...", path);
+
let mut type_resolver = TypeResolver::new(orig_crate, module, crate_types);
for item in syntax.items.iter() {
ExportStatus::Export => {},
ExportStatus::NoExport|ExportStatus::TestOnly => continue,
}
- if t.generics.lt_token.is_none() {
- writeln_opaque(&mut out, &t.ident, &format!("{}", t.ident), &t.generics, &t.attrs, &type_resolver, header_file, cpp_header_file);
+
+ let mut process_alias = true;
+ for tok in t.generics.params.iter() {
+ if let syn::GenericParam::Lifetime(_) = tok {}
+ else { process_alias = false; }
+ }
+ if process_alias {
+ match &*t.ty {
+ syn::Type::Path(_) =>
+ writeln_opaque(&mut out, &t.ident, &format!("{}", t.ident), &t.generics, &t.attrs, &type_resolver, header_file, cpp_header_file),
+ _ => {}
+ }
}
}
},
ast_storage.files.insert(module, syntax);
}
+/// Insert ident -> absolute Path resolutions into imports from the given UseTree and path-prefix.
+fn process_use_intern<'a>(u: &'a syn::UseTree, mut path: syn::punctuated::Punctuated<syn::PathSegment, syn::token::Colon2>, imports: &mut HashMap<&'a syn::Ident, syn::Path>) {
+ match u {
+ syn::UseTree::Path(p) => {
+ path.push(syn::PathSegment { ident: p.ident.clone(), arguments: syn::PathArguments::None });
+ process_use_intern(&p.tree, path, imports);
+ },
+ syn::UseTree::Name(n) => {
+ path.push(syn::PathSegment { ident: n.ident.clone(), arguments: syn::PathArguments::None });
+ imports.insert(&n.ident, syn::Path { leading_colon: Some(syn::Token)), segments: path });
+ },
+ syn::UseTree::Group(g) => {
+ for i in g.items.iter() {
+ process_use_intern(i, path.clone(), imports);
+ }
+ },
+ _ => {}
+ }
+}
+
+/// Map all the Paths in a Type into absolute paths given a set of imports (generated via process_use_intern)
+fn resolve_imported_refs(imports: &HashMap<&syn::Ident, syn::Path>, mut ty: syn::Type) -> syn::Type {
+ match &mut ty {
+ syn::Type::Path(p) => {
+ if let Some(ident) = p.path.get_ident() {
+ if let Some(newpath) = imports.get(ident) {
+ p.path = newpath.clone();
+ }
+ } else { unimplemented!(); }
+ },
+ syn::Type::Reference(r) => {
+ r.elem = Box::new(resolve_imported_refs(imports, (*r.elem).clone()));
+ },
+ syn::Type::Slice(s) => {
+ s.elem = Box::new(resolve_imported_refs(imports, (*s.elem).clone()));
+ },
+ syn::Type::Tuple(t) => {
+ for e in t.elems.iter_mut() {
+ *e = resolve_imported_refs(imports, e.clone());
+ }
+ },
+ _ => unimplemented!(),
+ }
+ ty
+}
+
/// Walk the FullLibraryAST, deciding how things will be mapped and adding tracking to CrateTypes.
fn walk_ast<'a>(in_dir: &str, path: &str, module: String, ast_storage: &'a FullLibraryAST, crate_types: &mut CrateTypes<'a>) {
let syntax = if let Some(ast) = ast_storage.files.get(&module) { ast } else { return };
walk_ast(in_dir, &path, new_mod, ast_storage, crate_types);
}
+ let mut import_maps = HashMap::new();
+
for item in syntax.items.iter() {
match item {
+ syn::Item::Use(u) => {
+ process_use_intern(&u.tree, syn::punctuated::Punctuated::new(), &mut import_maps);
+ },
syn::Item::Struct(s) => {
if let syn::Visibility::Public(_) = s.vis {
match export_status(&s.attrs) {
crate_types.traits.insert(trait_path, &t);
}
},
+ syn::Item::Type(t) => {
+ if let syn::Visibility::Public(_) = t.vis {
+ match export_status(&t.attrs) {
+ ExportStatus::Export => {},
+ ExportStatus::NoExport|ExportStatus::TestOnly => continue,
+ }
+ let type_path = format!("{}::{}", module, t.ident);
+ let mut process_alias = true;
+ for tok in t.generics.params.iter() {
+ if let syn::GenericParam::Lifetime(_) = tok {}
+ else { process_alias = false; }
+ }
+ if process_alias {
+ match &*t.ty {
+ syn::Type::Path(_) => {
+ // If its a path with no generics, assume we don't map the aliased type and map it opaque
+ crate_types.opaques.insert(type_path, &t.ident);
+ },
+ _ => {
+ crate_types.type_aliases.insert(type_path, resolve_imported_refs(&import_maps, (*t.ty).clone()));
+ }
+ }
+ }
+ }
+ },
syn::Item::Enum(e) if is_enum_opaque(e) => {
if let syn::Visibility::Public(_) = e.vis {
match export_status(&e.attrs) {
// ...then walk the ASTs tracking what types we will map, and how, so that we can resolve them
// when parsing other file ASTs...
let mut libtypes = CrateTypes { traits: HashMap::new(), opaques: HashMap::new(), mirrored_enums: HashMap::new(),
- templates_defined: HashMap::new(), template_file: &mut derived_templates };
+ type_aliases: HashMap::new(), templates_defined: HashMap::new(), template_file: &mut derived_templates };
walk_ast(&args[1], "/lib.rs", "".to_string(), &libast, &mut libtypes);
// ... finally, do the actual file conversion/mapping, writing out types as we go.
pub mirrored_enums: HashMap<String, &'a syn::ItemEnum>,
/// Traits which are mapped as a pointer + jump table
pub traits: HashMap<String, &'a syn::ItemTrait>,
+ /// Aliases from paths to some other Type
+ pub type_aliases: HashMap<String, syn::Type>,
/// Template continer types defined, map from mangled type name -> whether a destructor fn
/// exists.
///
}
let resolved_path = self.resolve_path(&p.path, generics);
- if let Some(c_type) = path_lookup(&resolved_path, is_ref, ptr_for_ref) {
+ if let Some(aliased_type) = self.crate_types.type_aliases.get(&resolved_path) {
+ return self.write_conversion_inline_intern(w, aliased_type, None, is_ref, is_mut, ptr_for_ref, tupleconv, prefix, sliceconv, path_lookup, decl_lookup);
+ } else if let Some(c_type) = path_lookup(&resolved_path, is_ref, ptr_for_ref) {
write!(w, "{}", c_type).unwrap();
} else if self.crate_types.opaques.get(&resolved_path).is_some() {
decl_lookup(w, &DeclType::StructImported, &resolved_path, is_ref, is_mut);
unimplemented!();
}
let resolved_path = self.resolve_path(&p.path, generics);
+ if let Some(aliased_type) = self.crate_types.type_aliases.get(&resolved_path) {
+ return self.write_conversion_new_var_intern(w, ident, var, aliased_type, None, is_ref, ptr_for_ref, to_c, path_lookup, container_lookup, var_prefix, var_suffix);
+ }
if self.is_known_container(&resolved_path, is_ref) || self.is_transparent_container(&resolved_path, is_ref) {
if let syn::PathArguments::AngleBracketed(args) = &p.path.segments.iter().next().unwrap().arguments {
convert_container!(resolved_path, args.args.len(), || args.args.iter().map(|arg| {
if self.is_known_container(&full_path, is_ref) || self.is_transparent_container(&full_path, is_ref) {
return self.write_c_mangled_container_path(w, Self::path_to_generic_args(&p.path), generics, &full_path, is_ref, is_mut, ptr_for_ref);
}
+ if let Some(aliased_type) = self.crate_types.type_aliases.get(&full_path).cloned() {
+ return self.write_c_type_intern(w, &aliased_type, None, is_ref, is_mut, ptr_for_ref);
+ }
}
self.write_c_path_intern(w, &p.path, generics, is_ref, is_mut, ptr_for_ref)
},
projects / rust-lightning / commitdiff