Metadata writer refactoring

.github/workflows/clippy.yml

@@ -113,7 +113,6 @@ jobs:
  cargo clippy -p test_window_long &&
  cargo clippy -p test_winrt &&
  cargo clippy -p tool_gnu &&
- cargo clippy -p tool_ilrs &&
  cargo clippy -p tool_lib &&
  cargo clippy -p tool_license &&
  cargo clippy -p tool_msvc &&

.github/workflows/test.yml

@@ -132,8 +132,8 @@ jobs:
  cargo test --target ${{ matrix.target }} -p test_enums &&
  cargo test --target ${{ matrix.target }} -p test_error &&
  cargo test --target ${{ matrix.target }} -p test_event &&
- cargo test --target ${{ matrix.target }} -p test_extensions &&
  cargo clean &&
+ cargo test --target ${{ matrix.target }} -p test_extensions &&
  cargo test --target ${{ matrix.target }} -p test_handles &&
  cargo test --target ${{ matrix.target }} -p test_helpers &&
  cargo test --target ${{ matrix.target }} -p test_implement &&
@@ -163,7 +163,6 @@ jobs:
  cargo test --target ${{ matrix.target }} -p test_window_long &&
  cargo test --target ${{ matrix.target }} -p test_winrt &&
  cargo test --target ${{ matrix.target }} -p tool_gnu &&
- cargo test --target ${{ matrix.target }} -p tool_ilrs &&
  cargo test --target ${{ matrix.target }} -p tool_lib &&
  cargo test --target ${{ matrix.target }} -p tool_license &&
  cargo test --target ${{ matrix.target }} -p tool_msvc &&

crates/libs/bindgen/src/com_methods.rs

@@ -196,9 +196,9 @@ pub fn gen_upcall(gen: &Gen, sig: &Signature, inner: TokenStream) -> TokenStream
 fn gen_win32_invoke_arg(gen: &Gen, param: &SignatureParam) -> TokenStream {
  let name = gen.param_name(param.def);
 
- if gen.reader.param_flags(param.def).input() && gen.reader.type_is_nullable(&param.ty) {
+ if gen.reader.param_flags(param.def).contains(ParamAttributes::INPUT) && gen.reader.type_is_nullable(&param.ty) {
  quote! { ::windows::core::from_raw_borrowed(&#name) }
- } else if (!param.ty.is_pointer() && gen.reader.type_is_nullable(&param.ty)) || (gen.reader.param_flags(param.def).input() && !gen.reader.type_is_primitive(&param.ty)) {
+ } else if (!param.ty.is_pointer() && gen.reader.type_is_nullable(&param.ty)) || (gen.reader.param_flags(param.def).contains(ParamAttributes::INPUT) && !gen.reader.type_is_primitive(&param.ty)) {
  quote! { ::core::mem::transmute(&#name) }
  } else {
  quote! { ::core::mem::transmute_copy(&#name) }

crates/libs/bindgen/src/delegates.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 pub fn gen(gen: &Gen, def: TypeDef) -> TokenStream {
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  gen_delegate(gen, def)
  } else {
  gen_callback(gen, def)

crates/libs/bindgen/src/enums.rs

@@ -14,7 +14,7 @@ pub fn gen(gen: &Gen, def: TypeDef) -> TokenStream {
  .reader
  .type_def_fields(def)
  .filter_map(|field| {
- if gen.reader.field_flags(field).literal() {
+ if gen.reader.field_flags(field).contains(FieldAttributes::LITERAL) {
  let field_name = to_ident(gen.reader.field_name(field));
  let constant = gen.reader.field_constant(field).unwrap();
  let value = gen.value(&gen.reader.constant_value(constant));
@@ -170,7 +170,7 @@ pub fn gen(gen: &Gen, def: TypeDef) -> TokenStream {
  });
  }
 
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  let signature = Literal::byte_string(gen.reader.type_def_signature(def, &[]).as_bytes());
 
  tokens.combine(&quote! {

crates/libs/bindgen/src/functions.rs

@@ -244,7 +244,7 @@ fn does_not_return(gen: &Gen, def: MethodDef) -> TokenStream {
 
 fn handle_last_error(gen: &Gen, def: MethodDef, signature: &Signature) -> bool {
  if let Some(map) = gen.reader.method_def_impl_map(def) {
- if gen.reader.impl_map_flags(map).last_error() {
+ if gen.reader.impl_map_flags(map).contains(PInvokeAttributes::LAST_ERROR) {
  if let Some(Type::TypeDef((return_type, _))) = &signature.return_type {
  if gen.reader.type_def_is_handle(*return_type) {
  if gen.reader.type_def_underlying_type(*return_type).is_pointer() {

crates/libs/bindgen/src/gen.rs

@@ -181,7 +181,7 @@ impl<'a> Gen<'a> {
  }
  }
  TypeKind::Delegate => {
- if self.reader.type_def_flags(*def).winrt() {
+ if self.reader.type_def_flags(*def).contains(TypeAttributes::WINRT) {
  quote! { *mut ::core::ffi::c_void }
  } else {
  self.type_def_name(*def, &[])
@@ -619,7 +619,7 @@ impl<'a> Gen<'a> {
  }
  }
  pub fn interface_winrt_trait(&self, def: TypeDef, generics: &[Type], ident: &TokenStream, constraints: &TokenStream, _phantoms: &TokenStream, features: &TokenStream) -> TokenStream {
- if self.reader.type_def_flags(def).winrt() {
+ if self.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  let type_signature = if self.reader.type_def_kind(def) == TypeKind::Class {
  let type_signature = Literal::byte_string(self.reader.type_def_signature(def, generics).as_bytes());
  quote! { ::windows::core::ConstBuffer::from_slice(#type_signature) }
@@ -673,7 +673,7 @@ impl<'a> Gen<'a> {
  }
  }
  pub fn runtime_name_trait(&self, def: TypeDef, _generics: &[Type], name: &TokenStream, constraints: &TokenStream, features: &TokenStream) -> TokenStream {
- if self.reader.type_def_flags(def).winrt() {
+ if self.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  // TODO: this needs to use a ConstBuffer-like facility to accomodate generics
  let runtime_name = format!("{}", self.reader.type_def_type_name(def));
 
@@ -793,7 +793,7 @@ impl<'a> Gen<'a> {
  }
  }
  pub fn vtbl_signature(&self, def: TypeDef, _generics: &[Type], signature: &Signature) -> TokenStream {
- let is_winrt = self.reader.type_def_flags(def).winrt();
+ let is_winrt = self.reader.type_def_flags(def).contains(TypeAttributes::WINRT);
  let hresult = self.type_name(&Type::HRESULT);
 
  let (trailing_return_type, return_type, udt_return_type) = if is_winrt {
@@ -826,7 +826,7 @@ impl<'a> Gen<'a> {
  let abi = self.type_abi_name(&p.ty);
  let abi_size_name: TokenStream = format!("{}_array_size", self.reader.param_name(p.def)).into();
 
- if self.reader.param_flags(p.def).input() {
+ if self.reader.param_flags(p.def).contains(ParamAttributes::INPUT) {
  if p.ty.is_winrt_array() {
  quote! { #abi_size_name: u32, #name: *const #abi, }
  } else if p.ty.is_winrt_const_ref() {
@@ -894,7 +894,7 @@ impl<'a> Gen<'a> {
  let flags = self.reader.param_flags(param.def);
  match param.kind {
  SignatureParamKind::ArrayFixed(_) | SignatureParamKind::ArrayRelativeLen(_) | SignatureParamKind::ArrayRelativeByteLen(_) => {
- let map = if flags.optional() {
+ let map = if flags.contains(ParamAttributes::OPTIONAL) {
  quote! { #name.as_deref().map_or(::core::ptr::null(), |slice|slice.as_ptr()) }
  } else {
  quote! { #name.as_ptr() }
@@ -904,7 +904,7 @@ impl<'a> Gen<'a> {
  SignatureParamKind::ArrayRelativePtr(relative) => {
  let name = self.param_name(params[relative].def);
  let flags = self.reader.param_flags(params[relative].def);
- if flags.optional() {
+ if flags.contains(ParamAttributes::OPTIONAL) {
  quote! { #name.as_deref().map_or(0, |slice|slice.len() as _), }
  } else {
  quote! { #name.len() as _, }
@@ -920,7 +920,7 @@ impl<'a> Gen<'a> {
  quote! { #name.into(), }
  }
  SignatureParamKind::OptionalPointer => {
- if flags.output() {
+ if flags.contains(ParamAttributes::OUTPUT) {
  quote! { ::core::mem::transmute(#name.unwrap_or(::std::ptr::null_mut())), }
  } else {
  quote! { ::core::mem::transmute(#name.unwrap_or(::std::ptr::null())), }
@@ -967,12 +967,12 @@ impl<'a> Gen<'a> {
  let ty = param.ty.deref();
  let ty = self.type_default_name(&ty);
  let len = Literal::u32_unsuffixed(fixed as _);
- let ty = if self.reader.param_flags(param.def).output() {
+ let ty = if self.reader.param_flags(param.def).contains(ParamAttributes::OUTPUT) {
  quote! { &mut [#ty; #len] }
  } else {
  quote! { &[#ty; #len] }
  };
- if self.reader.param_flags(param.def).optional() {
+ if self.reader.param_flags(param.def).contains(ParamAttributes::OPTIONAL) {
  tokens.combine(&quote! { #name: ::core::option::Option<#ty>, });
  } else {
  tokens.combine(&quote! { #name: #ty, });
@@ -981,24 +981,24 @@ impl<'a> Gen<'a> {
  SignatureParamKind::ArrayRelativeLen(_) => {
  let ty = param.ty.deref();
  let ty = self.type_default_name(&ty);
- let ty = if self.reader.param_flags(param.def).output() {
+ let ty = if self.reader.param_flags(param.def).contains(ParamAttributes::OUTPUT) {
  quote! { &mut [#ty] }
  } else {
  quote! { &[#ty] }
  };
- if self.reader.param_flags(param.def).optional() {
+ if self.reader.param_flags(param.def).contains(ParamAttributes::OPTIONAL) {
  tokens.combine(&quote! { #name: ::core::option::Option<#ty>, });
  } else {
  tokens.combine(&quote! { #name: #ty, });
  }
  }
  SignatureParamKind::ArrayRelativeByteLen(_) => {
- let ty = if self.reader.param_flags(param.def).output() {
+ let ty = if self.reader.param_flags(param.def).contains(ParamAttributes::OUTPUT) {
  quote! { &mut [u8] }
  } else {
  quote! { &[u8] }
  };
- if self.reader.param_flags(param.def).optional() {
+ if self.reader.param_flags(param.def).contains(ParamAttributes::OPTIONAL) {
  tokens.combine(&quote! { #name: ::core::option::Option<#ty>, });
  } else {
  tokens.combine(&quote! { #name: #ty, });
@@ -1029,7 +1029,7 @@ impl<'a> Gen<'a> {
  }
 
  pub fn impl_signature(&self, def: TypeDef, signature: &Signature) -> TokenStream {
- if self.reader.type_def_flags(def).winrt() {
+ if self.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  let is_delegate = self.reader.type_def_kind(def) == TypeKind::Delegate;
  let params = signature.params.iter().map(|p| self.winrt_produce_type(p, !is_delegate));
 
@@ -1084,7 +1084,7 @@ impl<'a> Gen<'a> {
  fn winrt_produce_type(&self, param: &SignatureParam, include_param_names: bool) -> TokenStream {
  let default_type = self.type_default_name(&param.ty);
 
- let sig = if self.reader.param_flags(param.def).input() {
+ let sig = if self.reader.param_flags(param.def).contains(ParamAttributes::INPUT) {
  if param.ty.is_winrt_array() {
  quote! { &[#default_type] }
  } else if self.reader.type_is_primitive(&param.ty) {
@@ -1115,7 +1115,7 @@ impl<'a> Gen<'a> {
  let name = self.param_name(param.def);
  let kind = self.type_default_name(&param.ty);
 
- if self.reader.param_flags(param.def).input() {
+ if self.reader.param_flags(param.def).contains(ParamAttributes::INPUT) {
  if self.reader.type_is_primitive(&param.ty) {
  quote! { #name: #kind, }
  } else if self.reader.type_is_nullable(&param.ty) {

crates/libs/bindgen/src/implements.rs

@@ -44,7 +44,7 @@ pub fn gen(gen: &Gen, def: TypeDef) -> TokenStream {
  }
  }
 
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  // TODO: this awkward wrapping of TypeDefs needs fixing
  for interface in gen.reader.type_interfaces(&Type::TypeDef((def, generics.to_vec()))) {
  if let Type::TypeDef((def, generics)) = interface.ty {
@@ -73,7 +73,7 @@ pub fn gen(gen: &Gen, def: TypeDef) -> TokenStream {
  let signature = gen.reader.method_def_signature(method, generics);
  let vtbl_signature = gen.vtbl_signature(def, generics, &signature);
 
- let invoke_upcall = if gen.reader.type_def_flags(def).winrt() { winrt_methods::gen_upcall(gen, &signature, quote! { this.#name }) } else { com_methods::gen_upcall(gen, &signature, quote! { this.#name }) };
+ let invoke_upcall = if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) { winrt_methods::gen_upcall(gen, &signature, quote! { this.#name }) } else { com_methods::gen_upcall(gen, &signature, quote! { this.#name }) };
 
  if has_unknown_base {
  quote! {

crates/libs/bindgen/src/interfaces.rs

@@ -61,7 +61,7 @@ fn gen_win_interface(gen: &Gen, def: TypeDef) -> TokenStream {
  let method_names = &mut MethodNames::new();
  let virtual_names = &mut MethodNames::new();
 
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  for method in gen.reader.type_def_methods(def) {
  methods.combine(&winrt_methods::gen(gen, def, generics, InterfaceKind::Default, method, method_names, virtual_names));
  }
@@ -141,7 +141,7 @@ fn gen_win_interface(gen: &Gen, def: TypeDef) -> TokenStream {
  }
  }
 
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  for interface in &interfaces {
  let into = gen.type_name(&interface.ty);
  let cfg = gen.cfg_features(&cfg.union(&gen.reader.type_cfg(&interface.ty)));

crates/libs/bindgen/src/lib.rs

@@ -53,7 +53,7 @@ pub fn namespace(gen: &Gen, tree: &Tree) -> String {
  let kind = gen.reader.type_def_kind(def);
  match kind {
  TypeKind::Class => {
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  types.entry(kind).or_default().insert(name, classes::gen(gen, def));
  } else {
  for method in gen.reader.type_def_methods(def) {

crates/libs/bindgen/src/structs.rs

@@ -36,13 +36,13 @@ fn gen_struct_with_name(gen: &Gen, def: TypeDef, struct_name: &str, cfg: &Cfg) -
  let name = to_ident(gen.reader.field_name(f));
  let ty = gen.reader.field_type(f, Some(def));
 
- if gen.reader.field_flags(f).literal() {
+ if gen.reader.field_flags(f).contains(FieldAttributes::LITERAL) {
  quote! {}
- } else if !gen.sys && flags.explicit_layout() && !gen.reader.field_is_copyable(f, def) {
+ } else if !gen.sys && flags.contains(TypeAttributes::EXPLICIT_LAYOUT) && !gen.reader.field_is_copyable(f, def) {
  // Rust can't tell that the type is copyable and won't accept windows::core::ManuallyDrop
  let ty = gen.type_default_name(&ty);
  quote! { pub #name: ::std::mem::ManuallyDrop<#ty>, }
- } else if !gen.sys && !flags.winrt() && !gen.reader.field_is_blittable(f, def) {
+ } else if !gen.sys && !flags.contains(TypeAttributes::WINRT) && !gen.reader.field_is_blittable(f, def) {
  if let Type::Win32Array((ty, len)) = ty {
  let ty = gen.type_name(&ty);
  quote! { pub #name: [::windows::core::ManuallyDrop<#ty>; #len], }
@@ -56,7 +56,7 @@ fn gen_struct_with_name(gen: &Gen, def: TypeDef, struct_name: &str, cfg: &Cfg) -
  }
  });
 
- let struct_or_union = if flags.explicit_layout() {
+ let struct_or_union = if flags.contains(TypeAttributes::EXPLICIT_LAYOUT) {
  quote! { union }
  } else {
  quote! { struct }
@@ -118,7 +118,7 @@ fn gen_windows_traits(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) ->
  }
  };
 
- if gen.reader.type_def_flags(def).winrt() {
+ if gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  let signature = Literal::byte_string(gen.reader.type_def_signature(def, &[]).as_bytes());
 
  let clone = if gen.reader.type_def_is_blittable(def) {
@@ -151,7 +151,7 @@ fn gen_compare_traits(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) ->
  } else {
  let fields = gen.reader.type_def_fields(def).filter_map(|f| {
  let name = to_ident(gen.reader.field_name(f));
- if gen.reader.field_flags(f).literal() {
+ if gen.reader.field_flags(f).contains(FieldAttributes::LITERAL) {
  None
  } else {
  Some(quote! { self.#name == other.#name })
@@ -179,7 +179,7 @@ fn gen_debug(gen: &Gen, def: TypeDef, ident: &TokenStream, cfg: &Cfg) -> TokenSt
  let features = gen.cfg_features(cfg);
 
  let fields = gen.reader.type_def_fields(def).filter_map(|f| {
- if gen.reader.field_flags(f).literal() {
+ if gen.reader.field_flags(f).contains(FieldAttributes::LITERAL) {
  None
  } else {
  let name = gen.reader.field_name(f);
@@ -221,7 +221,7 @@ fn gen_copy_clone(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) -> Tok
  } else if gen.reader.type_def_class_layout(def).is_some() {
  // Don't support copy/clone of packed structs: https://github.com/rust-lang/rust/issues/82523
  quote! {}
- } else if !gen.reader.type_def_flags(def).winrt() {
+ } else if !gen.reader.type_def_flags(def).contains(TypeAttributes::WINRT) {
  quote! {
  #features
  impl ::core::clone::Clone for #name {
@@ -233,7 +233,7 @@ fn gen_copy_clone(gen: &Gen, def: TypeDef, name: &TokenStream, cfg: &Cfg) -> Tok
  } else {
  let fields = gen.reader.type_def_fields(def).map(|f| {
  let name = to_ident(gen.reader.field_name(f));
- if gen.reader.field_flags(f).literal() {
+ if gen.reader.field_flags(f).contains(FieldAttributes::LITERAL) {
  quote! {}
  } else if gen.reader.field_is_blittable(f, def) {
  quote! { #name: self.#name }
@@ -257,7 +257,7 @@ fn gen_struct_constants(gen: &Gen, def: TypeDef, struct_name: &TokenStream, cfg:
  let features = gen.cfg_features(cfg);
 
  let constants = gen.reader.type_def_fields(def).filter_map(|f| {
- if gen.reader.field_flags(f).literal() {
+ if gen.reader.field_flags(f).contains(FieldAttributes::LITERAL) {
  if let Some(constant) = gen.reader.field_constant(f) {
  let name = to_ident(gen.reader.field_name(f));
  let value = gen.typed_value(&gen.reader.constant_value(constant));