ExportStatus::TestOnly => continue,
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
- if m.default.is_some() { unimplemented!(); }
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, types));
match item {
syn::TraitItem::Method(m) => {
if let ExportStatus::TestOnly = export_status(&m.attrs) { continue; }
- if m.default.is_some() { unimplemented!(); }
if m.sig.constness.is_some() || m.sig.asyncness.is_some() || m.sig.unsafety.is_some() ||
m.sig.abi.is_some() || m.sig.variadic.is_some() {
- unimplemented!();
+ panic!("1");
}
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, $type_resolver));
for inp in m.sig.inputs.iter() {
match inp {
syn::FnArg::Receiver(recv) => {
- if !recv.attrs.is_empty() || recv.reference.is_none() { unimplemented!(); }
+ if !recv.attrs.is_empty() || recv.reference.is_none() { panic!("2"); }
write!(w, "&").unwrap();
if let Some(lft) = &recv.reference.as_ref().unwrap().1 {
write!(w, "'{} ", lft.ident).unwrap();
}
},
syn::FnArg::Typed(arg) => {
- if !arg.attrs.is_empty() { unimplemented!(); }
+ if !arg.attrs.is_empty() { panic!("3"); }
match &*arg.pat {
syn::Pat::Ident(ident) => {
if !ident.attrs.is_empty() || ident.by_ref.is_some() ||
ident.mutability.is_some() || ident.subpat.is_some() {
- unimplemented!();
+ panic!("4");
}
write!(w, ", mut {}{}: ", if $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
}
- _ => unimplemented!(),
+ _ => panic!("5"),
}
$type_resolver.write_rust_type(w, Some(&gen_types), &*arg.ty);
}
write!(w, " {{\n\t\t").unwrap();
match export_status(&m.attrs) {
ExportStatus::NoExport => {
- unimplemented!();
+ panic!("6");
},
_ => {},
}
writeln!(w, "\n\t}}").unwrap();
},
&syn::TraitItem::Type(ref t) => {
- if t.default.is_some() || t.generics.lt_token.is_some() { unimplemented!(); }
+ if t.default.is_some() || t.generics.lt_token.is_some() { panic!("10"); }
let mut bounds_iter = t.bounds.iter();
loop {
match bounds_iter.next().unwrap() {
syn::TypeParamBound::Trait(tr) => {
writeln!(w, "\ttype {} = crate::{};", t.ident, $type_resolver.resolve_path(&tr.path, Some(&gen_types))).unwrap();
for bound in bounds_iter {
- if let syn::TypeParamBound::Trait(_) = bound { unimplemented!(); }
+ if let syn::TypeParamBound::Trait(_) = bound { panic!("11"); }
}
break;
},
}
}
},
- _ => unimplemented!(),
+ _ => panic!("12"),
}
}
}
writeln!(w, "\t}}\n}}\n").unwrap();
macro_rules! impl_meth {
- ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr) => {
+ ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr, $types: expr) => {
let trait_method = $trait.items.iter().filter_map(|item| {
if let syn::TraitItem::Method(t_m) = item { Some(t_m) } else { None }
}).find(|trait_meth| trait_meth.sig.ident == $m.sig.ident).unwrap();
}
write!(w, "extern \"C\" fn {}_{}_{}(", ident, $trait.ident, $m.sig.ident).unwrap();
let mut meth_gen_types = gen_types.push_ctx();
- assert!(meth_gen_types.learn_generics(&$m.sig.generics, types));
+ assert!(meth_gen_types.learn_generics(&$m.sig.generics, $types));
let mut uncallable_function = false;
for inp in $m.sig.inputs.iter() {
match inp {
syn::FnArg::Typed(arg) => {
- if types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { continue; }
+ if $types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { continue; }
let mut c_type = Vec::new();
- types.write_c_type(&mut c_type, &*arg.ty, Some(&meth_gen_types), false);
+ $types.write_c_type(&mut c_type, &*arg.ty, Some(&meth_gen_types), false);
if is_type_unconstructable(&String::from_utf8(c_type).unwrap()) {
uncallable_function = true;
}
}
}
if uncallable_function {
- let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ let mut trait_resolver = get_module_type_resolver!(full_trait_path, $types.crate_libs, $types.crate_types);
write_method_params(w, &$trait_meth.sig, "c_void", &mut trait_resolver, Some(&meth_gen_types), true, true);
} else {
- write_method_params(w, &$m.sig, "c_void", types, Some(&meth_gen_types), true, true);
+ write_method_params(w, &$m.sig, "c_void", $types, Some(&meth_gen_types), true, true);
}
write!(w, " {{\n\t").unwrap();
if uncallable_function {
write!(w, "unreachable!();").unwrap();
} else {
- write_method_var_decl_body(w, &$m.sig, "", types, Some(&meth_gen_types), false);
+ write_method_var_decl_body(w, &$m.sig, "", $types, Some(&meth_gen_types), false);
let mut takes_self = false;
for inp in $m.sig.inputs.iter() {
if let syn::FnArg::Receiver(_) = inp {
},
_ => {},
}
- write_method_call_params(w, &$m.sig, "", types, Some(&meth_gen_types), &real_type, false);
+ write_method_call_params(w, &$m.sig, "", $types, Some(&meth_gen_types), &real_type, false);
}
write!(w, "\n}}\n").unwrap();
if let syn::ReturnType::Type(_, rtype) = &$m.sig.output {
writeln!(w, "\t// This is a bit race-y in the general case, but for our specific use-cases today, we're safe").unwrap();
writeln!(w, "\t// Specifically, we must ensure that the first time we're called it can never be in parallel").unwrap();
write!(w, "\tif ").unwrap();
- types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident));
+ $types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident));
writeln!(w, " {{").unwrap();
writeln!(w, "\t\tunsafe {{ &mut *(trait_self_arg as *const {} as *mut {}) }}.{} = {}_{}_{}(trait_self_arg.this_arg);", $trait.ident, $trait.ident, $m.sig.ident, ident, $trait.ident, $m.sig.ident).unwrap();
writeln!(w, "\t}}").unwrap();
}
}
- 'impl_item_loop: for item in i.items.iter() {
- match item {
- syn::ImplItem::Method(m) => {
- for trait_item in trait_obj.items.iter() {
- match trait_item {
- syn::TraitItem::Method(meth) => {
+ 'impl_item_loop: for trait_item in trait_obj.items.iter() {
+ match trait_item {
+ syn::TraitItem::Method(meth) => {
+ for item in i.items.iter() {
+ match item {
+ syn::ImplItem::Method(m) => {
if meth.sig.ident == m.sig.ident {
- impl_meth!(m, meth, full_trait_path, trait_obj, "");
+ impl_meth!(m, meth, full_trait_path, trait_obj, "", types);
continue 'impl_item_loop;
}
},
- _ => {},
+ syn::ImplItem::Type(_) => {},
+ _ => unimplemented!(),
}
}
- unreachable!();
+ assert!(meth.default.is_some());
+ let old_gen_types = gen_types;
+ gen_types = GenericTypes::new(Some(resolved_path.clone()));
+ let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ impl_meth!(meth, meth, full_trait_path, trait_obj, "", &mut trait_resolver);
+ gen_types = old_gen_types;
},
- syn::ImplItem::Type(_) => {},
- _ => unimplemented!(),
+ _ => {},
}
}
if requires_clone {
if !gen_types.as_mut().unwrap().learn_generics(&i.generics, types) {
gen_types = None;
}
- 'alias_impls: for (alias, arguments) in aliases {
+ let alias_module = rsplit_once(&resolved_path, "::").unwrap().0;
+
+ 'alias_impls: for (alias_resolved, arguments) in aliases {
let mut new_ty_generics = Vec::new();
let mut need_generics = false;
- let alias_resolved = types.resolve_path(&alias, None);
+ let alias_resolver_override;
+ let alias_resolver = if alias_module != types.module_path {
+ alias_resolver_override = ImportResolver::new(types.types.crate_name, &types.crate_types.lib_ast.dependencies,
+ alias_module, &types.crate_types.lib_ast.modules.get(alias_module).unwrap().items);
+ &alias_resolver_override
+ } else { &types.types };/*.maybe_resolve_path(&alias, None).unwrap();*/
for (idx, gen) in i.generics.params.iter().enumerate() {
match gen {
syn::GenericParam::Type(type_param) => {
if let syn::PathArguments::AngleBracketed(ref t) = &arguments {
assert!(idx < t.args.len());
if let syn::GenericArgument::Type(syn::Type::Path(p)) = &t.args[idx] {
- if let Some(generic_arg) = types.maybe_resolve_path(&p.path, None) {
+ if let Some(generic_arg) = alias_resolver.maybe_resolve_path(&p.path, None) {
new_ty_generics.push((type_param.ident.clone(), syn::Type::Path(p.clone())));
- let generic_bound = types.resolve_path(&trait_bound.path, None);
+ let generic_bound = types.maybe_resolve_path(&trait_bound.path, None)
+ .unwrap_or_else(|| format!("{}::{}", types.module_path, single_ident_generic_path_to_ident(&trait_bound.path).unwrap()));
if let Some(traits_impld) = types.crate_types.trait_impls.get(&generic_arg) {
for trait_impld in traits_impld {
if *trait_impld == generic_bound { continue 'bounds_check; }
}
}
let mut params = syn::punctuated::Punctuated::new();
+ let alias = string_path_to_syn_path(&alias_resolved);
let real_aliased =
if need_generics {
let alias_generics = types.crate_types.opaques.get(&alias_resolved).unwrap().1;
match item {
syn::Item::Mod(m) => convert_priv_mod(w, libast, crate_types, out_dir, &format!("{}::{}", mod_path, module.ident), m),
syn::Item::Impl(i) => {
- if let &syn::Type::Path(ref p) = &*i.self_ty {
- if p.path.get_ident().is_some() {
- writeln_impl(w, i, &mut types);
- }
- }
+ writeln_impl(w, i, &mut types);
},
_ => {},
}
type_resolver.crate_types.priv_structs.get(&real_ty).map(|r| *r)).unwrap();
let mut resolved_generics = t.generics.clone();
+ // Assume blindly that the bounds in the struct definition where
+ // clause matches any equivalent bounds on the type alias.
+ assert!(resolved_generics.where_clause.is_none());
+ resolved_generics.where_clause = real_generic_bounds.where_clause.clone();
+
if let syn::PathArguments::AngleBracketed(real_generics) = &p.path.segments.last().unwrap().arguments {
for (real_idx, real_param) in real_generics.args.iter().enumerate() {
if let syn::GenericArgument::Type(syn::Type::Path(real_param_path)) = real_param {
let type_path = format!("{}::{}", module, t.ident);
match &*t.ty {
syn::Type::Path(p) => {
- let t_ident = &t.ident;
-
// If its a path with no generics, assume we don't map the aliased type and map it opaque
- let path_obj = parse_quote!(#t_ident);
let args_obj = p.path.segments.last().unwrap().arguments.clone();
match crate_types.reverse_alias_map.entry(import_resolver.maybe_resolve_path(&p.path, None).unwrap()) {
- hash_map::Entry::Occupied(mut e) => { e.get_mut().push((path_obj, args_obj)); },
- hash_map::Entry::Vacant(e) => { e.insert(vec![(path_obj, args_obj)]); },
+ hash_map::Entry::Occupied(mut e) => { e.get_mut().push((type_path.clone(), args_obj)); },
+ hash_map::Entry::Vacant(e) => { e.insert(vec![(type_path.clone(), args_obj)]); },
}
- crate_types.opaques.insert(type_path, (t_ident, &t.generics));
+ crate_types.opaques.insert(type_path, (&t.ident, &t.generics));
},
_ => {
crate_types.type_aliases.insert(type_path, import_resolver.resolve_imported_refs((*t.ty).clone()));
projects / ldk-c-bindings / blobdiff