use std::env;
use std::fs::File;
use std::io::{Read, Write};
+use std::iter::FromIterator;
use std::process;
use proc_macro2::Span;
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() {
panic!("1");
(s, i) => {
if let Some(supertrait) = types.crate_types.traits.get(s) {
let resolver = get_module_type_resolver!(s, types.crate_libs, types.crate_types);
- writeln!(w, "impl {} for {} {{", s, trait_name).unwrap();
+
+ // Blindly assume that the same imports where `supertrait` is defined are also
+ // imported here. This will almost certainly break at some point, but it should be
+ // a compilation failure when it does so.
+ write!(w, "impl").unwrap();
+ maybe_write_lifetime_generics(w, &supertrait.generics, types);
+ write!(w, " {}", s).unwrap();
+ maybe_write_generics(w, &supertrait.generics, types, false);
+ writeln!(w, " for {} {{", trait_name).unwrap();
+
impl_trait_for_c!(supertrait, format!(".{}", i), &resolver);
writeln!(w, "}}").unwrap();
} else {
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 {
'alias_impls: for (alias_resolved, arguments) in aliases {
let mut new_ty_generics = Vec::new();
+ let mut new_ty_bounds = Vec::new();
let mut need_generics = false;
let alias_resolver_override;
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();*/
+ let mut where_clause = Some(syn::WhereClause {
+ where_token: syn::Token),
+ predicates: syn::punctuated::Punctuated::new()
+ });
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) = alias_resolver.maybe_resolve_path(&p.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(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.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; }
continue 'alias_impls;
}
} else if gen_types.is_some() {
- new_ty_generics.push((type_param.ident.clone(),
- gen_types.as_ref().resolve_type(&syn::Type::Path(p.clone())).clone()));
+ let resp = types.maybe_resolve_path(&p.path, gen_types.as_ref());
+ if generic_bound == "core::ops::Deref" && resp.is_some() {
+ new_ty_bounds.push((type_param.ident.clone(),
+ string_path_to_syn_path("core::ops::Deref")));
+ let mut bounds = syn::punctuated::Punctuated::new();
+ bounds.push(syn::TypeParamBound::Trait(syn::TraitBound {
+ paren_token: None,
+ modifier: syn::TraitBoundModifier::None,
+ lifetimes: None,
+ path: string_path_to_syn_path(&types.resolve_path(&p.path, gen_types.as_ref())),
+ }));
+ let mut path = string_path_to_syn_path(&format!("{}::Target", type_param.ident));
+ path.leading_colon = None;
+ where_clause.as_mut().unwrap().predicates.push(syn::WherePredicate::Type(syn::PredicateType {
+ lifetimes: None,
+ bounded_ty: syn::Type::Path(syn::TypePath { qself: None, path }),
+ colon_token: syn::Token),
+ bounds,
+ }));
+ } else {
+ new_ty_generics.push((type_param.ident.clone(),
+ gen_types.as_ref().resolve_type(&syn::Type::Path(p.clone())).clone()));
+ }
need_generics = true;
} else {
unimplemented!();
let alias_generics = types.crate_types.opaques.get(&alias_resolved).unwrap().1;
// If we need generics on the alias, create impl generic bounds...
- assert_eq!(new_ty_generics.len(), i.generics.params.len());
+ assert_eq!(new_ty_generics.len() + new_ty_bounds.len(), i.generics.params.len());
let mut args = syn::punctuated::Punctuated::new();
for (ident, param) in new_ty_generics.drain(..) {
// TODO: We blindly assume that generics in the type alias and
default: Some(param),
}));
}
+ for (ident, param) in new_ty_bounds.drain(..) {
+ // TODO: We blindly assume that generics in the type alias and
+ // the aliased type have the same names, which we really shouldn't.
+ if alias_generics.params.iter().any(|generic|
+ if let syn::GenericParam::Type(t) = generic { t.ident == ident } else { false })
+ {
+ args.push(parse_quote!(#ident));
+ }
+ params.push(syn::GenericParam::Type(syn::TypeParam {
+ attrs: Vec::new(),
+ ident,
+ colon_token: Some(syn::token::Colon(Span::call_site())),
+ bounds: syn::punctuated::Punctuated::from_iter(
+ Some(syn::TypeParamBound::Trait(syn::TraitBound {
+ path: param, paren_token: None, lifetimes: None,
+ modifier: syn::TraitBoundModifier::None,
+ }))
+ ),
+ eq_token: None,
+ default: None,
+ }));
+ }
// ... and swap the last segment of the impl self_ty to use the generic bounds.
let mut res = alias.clone();
res.segments.last_mut().unwrap().arguments = syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
lt_token: None,
params,
gt_token: None,
- where_clause: None,
+ where_clause,
},
impl_token: syn::Token),
items: i.items.clone(),
writeln_field_docs(w, &field.attrs, "\t\t", types, Some(&gen_types), &field.ty);
write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
write!(&mut constr, "{}{}: ", if idx != 0 { ", " } else { "" }, field.ident.as_ref().unwrap()).unwrap();
- types.write_c_type(w, &field.ty, Some(&gen_types), false);
- types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false);
+ types.write_c_type(w, &field.ty, Some(&gen_types), true);
+ types.write_c_type(&mut constr, &field.ty, Some(&gen_types), true);
writeln!(w, ",").unwrap();
}
write!(w, "\t}}").unwrap();
} else if let syn::Fields::Unnamed(fields) = &var.fields {
if fields.unnamed.len() == 1 {
let mut empty_check = Vec::new();
- types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false);
+ types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), true);
if empty_check.is_empty() {
empty_tuple_variant = true;
}
for (idx, field) in fields.unnamed.iter().enumerate() {
if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
write!(&mut constr, "{}: ", ('a' as u8 + idx as u8) as char).unwrap();
- types.write_c_type(w, &field.ty, Some(&gen_types), false);
+ types.write_c_type(w, &field.ty, Some(&gen_types), true);
types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false);
if idx != fields.unnamed.len() - 1 {
write!(w, ",").unwrap();
} else if let syn::Fields::Unnamed(fields) = &var.fields {
if !empty_tuple_variant {
write!(&mut constr, "(").unwrap();
- for idx in 0..fields.unnamed.len() {
- write!(&mut constr, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
+ for (idx, field) in fields.unnamed.iter().enumerate() {
+ let mut ref_c_ty = Vec::new();
+ let mut nonref_c_ty = Vec::new();
+ types.write_c_type(&mut ref_c_ty, &field.ty, Some(&gen_types), false);
+ types.write_c_type(&mut nonref_c_ty, &field.ty, Some(&gen_types), true);
+
+ if ref_c_ty != nonref_c_ty {
+ // We blindly assume references in field types are always opaque types, and
+ // print out an opaque reference -> owned reference conversion here.
+ write!(&mut constr, "{} {{ inner: {}.inner, is_owned: false }}, ", String::from_utf8(nonref_c_ty).unwrap(), ('a' as u8 + idx as u8) as char).unwrap();
+ } else {
+ write!(&mut constr, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
+ }
}
writeln!(&mut constr, ")").unwrap();
} else {
writeln!(&mut constr, "}}").unwrap();
writeln!(w, ",").unwrap();
}
- writeln!(w, "}}\nuse {}::{} as native{};\nimpl {} {{", types.module_path, e.ident, e.ident, e.ident).unwrap();
+ writeln!(w, "}}\nuse {}::{} as {}Import;", types.module_path, e.ident, e.ident).unwrap();
+ write!(w, "pub(crate) type native{} = {}Import", e.ident, e.ident).unwrap();
+ maybe_write_generics(w, &e.generics, &types, true);
+ writeln!(w, ";\n\nimpl {} {{", e.ident).unwrap();
macro_rules! write_conv {
($fn_sig: expr, $to_c: expr, $ref: expr) => {
} else if let syn::Fields::Unnamed(fields) = &var.fields {
if fields.unnamed.len() == 1 {
let mut empty_check = Vec::new();
- types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false);
+ types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), true);
if empty_check.is_empty() {
empty_tuple_variant = true;
}
let mut sink = ::std::io::sink();
let mut out: &mut dyn std::io::Write = if $ref { &mut sink } else { w };
let new_var = if $to_c {
- types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types), false)
+ types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types), true)
} else {
types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types))
};
if new_var {
let nonref_ident = format_ident!("{}_nonref", $field_ident);
if $to_c {
- types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types), false);
+ types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types), true);
} else {
types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types));
}
($field: expr, $field_ident: expr) => { {
if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
if $to_c {
- types.write_to_c_conversion_inline_prefix(w, &$field.ty, Some(&gen_types), false);
+ types.write_to_c_conversion_inline_prefix(w, &$field.ty, Some(&gen_types), true);
} else {
types.write_from_c_conversion_prefix(w, &$field.ty, Some(&gen_types));
}
write!(w, "{}{}", $field_ident,
if $ref { "_nonref" } else { "" }).unwrap();
if $to_c {
- types.write_to_c_conversion_inline_suffix(w, &$field.ty, Some(&gen_types), false);
+ types.write_to_c_conversion_inline_suffix(w, &$field.ty, Some(&gen_types), true);
} else {
types.write_from_c_conversion_suffix(w, &$field.ty, Some(&gen_types));
}
projects / ldk-c-bindings / blobdiff