chore: CI things

Author: Norbytus

crates/macros/src/function.rs

@@ -163,7 +163,6 @@ impl<'a> Function<'a> {
             #returns
             #docs
         }
-
     }
 
     /// Generates the function builder for the function.

crates/macros/src/impl_.rs

@@ -162,7 +162,7 @@ pub struct Constant<'a> {
 
 impl<'a> Constant<'a> {
     pub fn new(name: String, ident: &'a syn::Ident, docs: Vec<String>) -> Self {
-        Self {name, ident, docs}
+        Self { name, ident, docs }
     }
 }
 

crates/macros/src/interface.rs

@@ -1,14 +1,14 @@
 use std::collections::{HashMap, HashSet};
 
-use darling::util::Flag;
-use darling::{FromAttributes};
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use syn::{Expr, Ident, ItemTrait, Path, TraitItem, TraitItemConst, TraitItemFn};
 use crate::class::ClassEntryAttribute;
 use crate::constant::PhpConstAttribute;
 use crate::function::{Args, Function};
 use crate::helpers::{get_docs, CleanPhpAttr};
+use darling::util::Flag;
+use darling::FromAttributes;
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+use syn::{Expr, Ident, ItemTrait, Path, TraitItem, TraitItemConst, TraitItemFn};
 
 use crate::impl_::{Constant, FnBuilder, MethodModifier};
 use crate::parsing::{PhpRename, RenameRule, Visibility};
@@ -34,23 +34,22 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
     let name = attr.rename.rename(ident.to_string(), RenameRule::Pascal);
     input.attrs.clean_php();
 
-    let methods: Vec<FnBuilder> = input.items.iter_mut()
-        .flat_map(
-            |item: &mut TraitItem| {
-                match item {
-                    TraitItem::Fn(f) => Some(f),
-                    _ => None,
-                }
-            })
+    let methods: Vec<FnBuilder> = input
+        .items
+        .iter_mut()
+        .flat_map(|item: &mut TraitItem| match item {
+            TraitItem::Fn(f) => Some(f),
+            _ => None,
+        })
         .flat_map(|f| f.parse())
         .collect();
 
-    let constants: Vec<_> = input.items.iter_mut()
-        .flat_map(|item: &mut TraitItem| {
-            match item {
-                TraitItem::Const(c) => Some(c),
-                _ => None,
-            }
+    let constants: Vec<_> = input
+        .items
+        .iter_mut()
+        .flat_map(|item: &mut TraitItem| match item {
+            TraitItem::Const(c) => Some(c),
+            _ => None,
         })
         .flat_map(|c| c.parse())
         .map(|c| {
@@ -63,19 +62,19 @@ pub fn parser(mut input: ItemTrait) -> Result<TokenStream> {
         })
         .collect();
 
-    let impl_const: Vec<&TraitItemConst> = input.items.iter().flat_map(|item| {
-        match item {
+    let impl_const: Vec<&TraitItemConst> = input
+        .items
+        .iter()
+        .flat_map(|item| match item {
             TraitItem::Const(c) => Some(c),
             _ => None,
-        }
-    })
-    .map(|c| {
+        })
+        .flat_map(|c| {
             if c.default.is_none() {
                 bail!("Interface const cannot be empty");
             }
             Ok(c)
         })
-        .flat_map(|c| c)
         .collect();
 
     let implements = attr.extends;
@@ -256,17 +255,12 @@ impl<'a> Parse<'a, Constant<'a>> for TraitItemConst {
 
 impl<'a> Parse<'a, FnBuilder> for TraitItemFn {
     fn parse(&'a mut self) -> Result<FnBuilder> {
-        let php_attr = PhpFunctionInterfaceAttribute::from_attributes(
-            &self.attrs
-        )?;
+        let php_attr = PhpFunctionInterfaceAttribute::from_attributes(&self.attrs)?;
         if self.default.is_some() {
             bail!("Interface could not have default impl");
         }
 
-        let mut args = Args::parse_from_fnargs(
-            self.sig.inputs.iter(),
-            php_attr.defaults
-        )?;
+        let mut args = Args::parse_from_fnargs(self.sig.inputs.iter(), php_attr.defaults)?;
         let docs = get_docs(&php_attr.attrs)?;
 
         self.attrs.clean_php();

crates/macros/src/lib.rs

@@ -15,7 +15,9 @@ mod zval;
 
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
-use syn::{DeriveInput, ItemConst, ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemStruct, ItemTrait};
+use syn::{
+    DeriveInput, ItemConst, ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemStruct, ItemTrait,
+};
 
 extern crate proc_macro;
 
@@ -386,11 +388,9 @@ pub fn php_interface(args: TokenStream, input: TokenStream) -> TokenStream {
 }
 
 fn php_interface_internal(_args: TokenStream2, input: TokenStream2) -> TokenStream2 {
-    let input = parse_macro_input2!(input as ItemTrait).into();
+    let input = parse_macro_input2!(input as ItemTrait);
 
-    interface::parser(input)
-        .unwrap_or_else(|e| e.to_compile_error())
-        .into()
+    interface::parser(input).unwrap_or_else(|e| e.to_compile_error())
 }
 
 // BEGIN DOCS FROM function.md

src/builders/class.rs

@@ -303,7 +303,7 @@ impl ClassBuilder {
 
         let class = if self.ce.flags().contains(ClassFlags::Interface) {
             unsafe {
-                zend_register_internal_interface(&mut self.ce)
+                zend_register_internal_interface(&raw mut self.ce)
                     .as_mut()
                     .ok_or(Error::InvalidPointer)?
             }

src/builders/module.rs

@@ -1,8 +1,6 @@
 use std::{convert::TryFrom, ffi::CString, mem, ptr};
 
 use super::{ClassBuilder, FunctionBuilder};
-#[cfg(feature = "enum")]
-use crate::{builders::enum_builder::EnumBuilder, enum_::RegisteredEnum};
 use crate::{
     builders::class::InterfaceBuilder,
     class::RegisteredClass,
@@ -13,6 +11,8 @@ use crate::{
     zend::{FunctionEntry, ModuleEntry},
     PHP_DEBUG, PHP_ZTS,
 };
+#[cfg(feature = "enum")]
+use crate::{builders::enum_builder::EnumBuilder, enum_::RegisteredEnum};
 
 /// Builds a Zend module extension to be registered with PHP. Must be called
 /// from within an external function called `get_module`, returning a mutable
@@ -173,6 +173,11 @@ impl ModuleBuilder<'_> {
         self
     }
 
+    /// Adds a interface to the extension.
+    ///
+    /// # Panics
+    ///
+    /// * Panics if a constant could not be registered.
     pub fn interface<T: RegisteredClass>(mut self) -> Self {
         self.classes.push(|| {
             let mut builder = InterfaceBuilder::new(T::CLASS_NAME);

tests/src/integration/interface/mod.rs

@@ -1,15 +1,14 @@
 use std::collections::HashMap;
 
 use ext_php_rs::types::ZendClassObject;
+use ext_php_rs::zend::ce;
 use ext_php_rs::{php_class, php_impl, php_interface};
 use ext_php_rs::{php_module, prelude::ModuleBuilder};
-use ext_php_rs::zend::ce;
 
 #[php_interface]
 #[php(extends(ce = ce::throwable, stub = "\\Throwable"))]
 #[php(name = "ExtPhpRs\\Interface\\EmptyObjectInterface")]
-pub trait EmptyObjectTrait
-{
+pub trait EmptyObjectTrait {
     const HELLO: &'static str = "HELLO";
 
     fn void();
@@ -19,7 +18,7 @@ pub trait EmptyObjectTrait
     fn ref_to_like_this_class(
         &self,
         data: String,
-        other: &ZendClassObject<PhpInterfaceEmptyObjectTrait>
+        other: &ZendClassObject<PhpInterfaceEmptyObjectTrait>,
     ) -> String;
 }
 

tests/src/integration/mod.rs

@@ -9,6 +9,7 @@ pub mod defaults;
 pub mod enum_;
 pub mod exception;
 pub mod globals;
+pub mod interface;
 pub mod iterator;
 pub mod magic_method;
 pub mod nullable;
@@ -17,7 +18,6 @@ pub mod object;
 pub mod string;
 pub mod types;
 pub mod variadic_args;
-pub mod interface;
 
 #[cfg(test)]
 mod test {