use super::guid;
use super::*;
syn::custom_keyword!(interface);
syn::custom_keyword!(event);
#[derive(Debug)]
pub struct Interface {
pub attrs: Vec<syn::Attribute>,
pub token: interface,
pub name: syn::Ident,
pub generics: syn::Generics,
pub requires: Vec<syn::Path>,
pub members: Vec<InterfaceMember>,
pub winrt: bool,
}
#[derive(Debug)]
pub struct Property {
pub attrs: Vec<syn::Attribute>,
pub name: syn::Ident,
pub ty: syn::Type,
}
#[derive(Debug)]
pub struct Event {
pub name: syn::Ident,
pub handler_ty: syn::Type,
}
#[derive(Debug)]
pub enum InterfaceMember {
Method(Method),
Property(Property),
Event(Event),
}
impl syn::parse::Parse for InterfaceMember {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let fork = input.fork();
fork.call(syn::Attribute::parse_outer)?;
if fork.peek(syn::Token![fn]) {
return input.parse().map(Self::Method);
}
if fork.peek(event) {
input.call(syn::Attribute::parse_outer)?;
let _event_token: event = input.parse()?;
let name: syn::Ident = input.parse()?;
input.parse::<syn::Token![:]>()?;
let handler_ty: syn::Type = input.parse()?;
input.parse::<syn::Token![;]>()?;
return Ok(Self::Event(Event { name, handler_ty }));
}
let attrs = input.call(syn::Attribute::parse_outer)?;
let name: syn::Ident = input.parse()?;
input.parse::<syn::Token![:]>()?;
let ty: syn::Type = input.parse()?;
input.parse::<syn::Token![;]>()?;
Ok(Self::Property(Property { attrs, name, ty }))
}
}
impl syn::parse::Parse for Interface {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let attrs = input.call(syn::Attribute::parse_outer)?;
let token = input.parse()?;
let name = input.parse()?;
let generics = input.parse()?;
let requires = if input.parse::<syn::Token![:]>().is_ok() {
let mut requires = vec![input.parse::<syn::Path>()?];
while input.parse::<syn::Token![+]>().is_ok() {
requires.push(input.parse::<syn::Path>()?);
}
requires
} else {
vec![]
};
let content;
syn::braced!(content in input);
let mut members = vec![];
while !content.is_empty() {
members.push(content.parse()?);
}
Ok(Self {
attrs,
token,
name,
generics,
requires,
members,
winrt: false,
})
}
}
impl Encoder<'_> {
pub fn encode_interface(&mut self, item: &Interface) -> Result<(), Error> {
let has_exclusive_to = item
.attrs
.iter()
.any(|attr| self.is_exclusive_to_attribute(attr));
let mut flags = metadata::TypeAttributes::Abstract | metadata::TypeAttributes::Interface;
if !has_exclusive_to {
flags |= metadata::TypeAttributes::Public;
}
if item.winrt {
flags |= metadata::TypeAttributes::WindowsRuntime;
}
let mut generics = Vec::with_capacity(item.generics.params.len());
for generic in &item.generics.params {
let syn::GenericParam::Type(generic) = generic else {
return self.err(generic, "only type generic parameters are supported");
};
generics.push(generic.ident.to_string());
}
self.generics = generics;
let mut name = self.name.to_string();
if !self.generics.is_empty() {
name = format!("{name}`{}", self.generics.len());
}
let interface = self.output.TypeDef(
self.namespace,
&name,
metadata::writer::TypeDefOrRef::default(),
flags,
);
for (number, name) in self.generics.iter().enumerate() {
self.output.GenericParam(
name,
metadata::writer::TypeOrMethodDef::TypeDef(interface),
number.try_into().unwrap(),
metadata::GenericParamAttributes::None,
);
}
self.encode_attrs(
metadata::writer::HasAttribute::TypeDef(interface),
&item.attrs,
&["guid", "no_guid"],
)?;
if let Some(arch_bits) = self.read_arch(&item.attrs)? {
self.emit_arch_attribute(
metadata::writer::HasAttribute::TypeDef(interface),
arch_bits,
);
}
let already_has_guid = self.encode_guid_pseudo_attrs(
metadata::writer::HasAttribute::TypeDef(interface),
&item.attrs,
)?;
if !item.winrt && item.requires.len() > 1 {
return self.err(
&item.requires[1],
"non-WinRT interface can only inherit from one interface",
);
}
for require in &item.requires {
let ty = self.encode_path(require)?;
self.output.InterfaceImpl(interface, &ty);
}
let base_flags = metadata::MethodAttributes::Public
| metadata::MethodAttributes::HideBySig
| metadata::MethodAttributes::Abstract
| metadata::MethodAttributes::NewSlot
| metadata::MethodAttributes::Virtual;
let mut method_signatures: Vec<(String, Vec<metadata::Type>, metadata::Type)> = Vec::new();
let mut property_map_started = false;
let mut event_map_started = false;
for member in &item.members {
match member {
InterfaceMember::Method(method) => {
let mut params = vec![];
if method.sig.inputs.is_empty() {
return self.err(&method.sig.ident, "`&self` parameter not found");
}
for (sequence, arg) in method.sig.inputs.iter().enumerate() {
match arg {
syn::FnArg::Receiver(receiver) => {
if *receiver != syn::parse_quote! { &self } {
return self.err(receiver, "`&self` parameter not found");
}
}
syn::FnArg::Typed(pt) => {
if sequence == 0 {
return self.err(arg, "`&self` parameter not found");
}
let p = self.param(pt)?;
if item.winrt {
self.validate_type_is_winrt(&pt.ty, &p.ty)?;
}
params.push(p);
}
}
}
let types: Vec<metadata::Type> =
params.iter().map(|param| param.ty.clone()).collect();
let return_type = self.encode_return_type(&method.sig.output)?;
if item.winrt
&& let syn::ReturnType::Type(_, return_syn_ty) = &method.sig.output
{
self.validate_type_is_winrt(return_syn_ty.as_ref(), &return_type)?;
}
if !already_has_guid {
method_signatures.push((
method.sig.ident.to_string(),
types.clone(),
return_type.clone(),
));
}
let signature = metadata::Signature {
flags: metadata::MethodCallAttributes::HASTHIS,
return_type,
types,
};
let mut is_special = false;
for attr in &method.attrs {
if attr.path().is_ident("special") {
if !matches!(attr.meta, syn::Meta::Path(_)) {
return self
.err(attr, "`special` attribute does not accept arguments");
}
is_special = true;
}
}
let mut flags = base_flags;
if is_special {
flags |= metadata::MethodAttributes::SpecialName;
}
let method_def = self.output.MethodDef(
&method.sig.ident.to_string(),
&signature,
flags,
Default::default(),
);
self.encode_attrs(
metadata::writer::HasAttribute::MethodDef(method_def),
&method.attrs,
&["special"],
)?;
self.encode_return_attrs(&method.return_attrs)?;
self.encode_params(¶ms)?;
}
InterfaceMember::Property(prop) => {
let is_get_only = prop.attrs.iter().any(|a| a.path().is_ident("get"));
let is_set_only = prop.attrs.iter().any(|a| a.path().is_ident("set"));
if is_get_only && is_set_only {
return self.err(
&prop.name,
"property cannot have both `#[get]` and `#[set]` attributes",
);
}
for attr in &prop.attrs {
if !attr.path().is_ident("get") && !attr.path().is_ident("set") {
return self.err(
attr,
"only `#[get]` and `#[set]` attributes are supported on properties",
);
}
if !matches!(attr.meta, syn::Meta::Path(_)) {
return self
.err(attr, "`get`/`set` attribute does not accept arguments");
}
}
let ty = self.encode_type(&prop.ty)?;
let method_flags = base_flags | metadata::MethodAttributes::SpecialName;
let mut get_method = None;
let mut put_method = None;
if !is_set_only {
let get_name = format!("get_{}", prop.name);
let signature = metadata::Signature {
flags: metadata::MethodCallAttributes::HASTHIS,
return_type: ty.clone(),
types: vec![],
};
if !already_has_guid {
method_signatures.push((get_name.clone(), vec![], ty.clone()));
}
get_method = Some(self.output.MethodDef(
&get_name,
&signature,
method_flags,
Default::default(),
));
self.encode_simple_params(&[])?;
}
if !is_get_only {
let put_name = format!("put_{}", prop.name);
let signature = metadata::Signature {
flags: metadata::MethodCallAttributes::HASTHIS,
return_type: metadata::Type::Void,
types: vec![ty.clone()],
};
if !already_has_guid {
method_signatures.push((
put_name.clone(),
vec![ty.clone()],
metadata::Type::Void,
));
}
put_method = Some(self.output.MethodDef(
&put_name,
&signature,
method_flags,
Default::default(),
));
self.encode_simple_params(&[("value", &ty)])?;
}
let property = self.output.Property(&prop.name.to_string(), &ty);
if !property_map_started {
self.output.PropertyMap(interface, property);
property_map_started = true;
}
if let Some(method) = get_method {
self.output.MethodSemantics(
0x0002, method,
metadata::writer::HasSemantics::Property(property),
);
}
if let Some(method) = put_method {
self.output.MethodSemantics(
0x0001, method,
metadata::writer::HasSemantics::Property(property),
);
}
}
InterfaceMember::Event(evt) => {
let handler_ty = self.encode_type(&evt.handler_ty)?;
let token_ty =
metadata::Type::value_named("Windows.Foundation", "EventRegistrationToken");
let method_flags = base_flags | metadata::MethodAttributes::SpecialName;
let add_name = format!("add_{}", evt.name);
let add_signature = metadata::Signature {
flags: metadata::MethodCallAttributes::HASTHIS,
return_type: token_ty.clone(),
types: vec![handler_ty.clone()],
};
if !already_has_guid {
method_signatures.push((
add_name.clone(),
vec![handler_ty.clone()],
token_ty.clone(),
));
}
let add_method = self.output.MethodDef(
&add_name,
&add_signature,
method_flags,
Default::default(),
);
self.encode_simple_params(&[("handler", &handler_ty)])?;
let remove_name = format!("remove_{}", evt.name);
let remove_signature = metadata::Signature {
flags: metadata::MethodCallAttributes::HASTHIS,
return_type: metadata::Type::Void,
types: vec![token_ty.clone()],
};
if !already_has_guid {
method_signatures.push((
remove_name.clone(),
vec![token_ty.clone()],
metadata::Type::Void,
));
}
let remove_method = self.output.MethodDef(
&remove_name,
&remove_signature,
method_flags,
Default::default(),
);
self.encode_simple_params(&[("token", &token_ty)])?;
let event = self.output.Event(&evt.name.to_string(), &handler_ty);
if !event_map_started {
self.output.EventMap(interface, event);
event_map_started = true;
}
self.output.MethodSemantics(
0x0008, add_method,
metadata::writer::HasSemantics::Event(event),
);
self.output.MethodSemantics(
0x0010, remove_method,
metadata::writer::HasSemantics::Event(event),
);
}
}
}
if !already_has_guid {
let methods: Vec<(&str, &[metadata::Type], &metadata::Type)> = method_signatures
.iter()
.map(|(name, types, ret)| (name.as_str(), types.as_slice(), ret))
.collect();
guid::derive_and_emit_guid(
self.output,
metadata::writer::HasAttribute::TypeDef(interface),
self.namespace,
self.name,
&methods,
);
}
Ok(())
}
}