1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-25 08:39:09 -05:00
denoland-deno/ops/optimizer.rs
Bartek Iwańczuk 702284dc22
perf(ops): directly respond for eager ops (#18683)
This commit changes "eager ops" to directly return a response value
instead of calling "opresponse" callback in JavaScript. This saves
one boundary crossing and has a fantastic impact on the "async_ops.js"
benchmark:

```
v1.32.4
$ deno run cli/bench/async_ops.js
time 329 ms rate 3039513
time 322 ms rate 3105590
time 307 ms rate 3257328
time 301 ms rate 3322259
time 303 ms rate 3300330
time 306 ms rate 3267973
time 300 ms rate 3333333
time 301 ms rate 3322259
time 301 ms rate 3322259
time 301 ms rate 3322259
time 302 ms rate 3311258
time 301 ms rate 3322259
time 302 ms rate 3311258
time 302 ms rate 3311258
time 303 ms rate 3300330
```

```
this branch
$ ./target/release/deno run -A cli/bench/async_ops.js
time 257 ms rate 3891050
time 248 ms rate 4032258
time 251 ms rate 3984063
time 246 ms rate 4065040
time 238 ms rate 4201680
time 227 ms rate 4405286
time 228 ms rate 4385964
time 229 ms rate 4366812
time 228 ms rate 4385964
time 226 ms rate 4424778
time 226 ms rate 4424778
time 227 ms rate 4405286
time 228 ms rate 4385964
time 227 ms rate 4405286
time 228 ms rate 4385964
time 227 ms rate 4405286
time 229 ms rate 4366812
time 228 ms rate 4385964
```

Prerequisite for https://github.com/denoland/deno/pull/18652
2023-04-13 14:32:47 +02:00

1004 lines
30 KiB
Rust

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
//! Optimizer for #[op]
use std::collections::BTreeMap;
use std::fmt::Debug;
use std::fmt::Formatter;
use pmutil::q;
use pmutil::Quote;
use proc_macro2::TokenStream;
use syn::parse_quote;
use syn::punctuated::Punctuated;
use syn::token::Colon2;
use syn::AngleBracketedGenericArguments;
use syn::FnArg;
use syn::GenericArgument;
use syn::PatType;
use syn::Path;
use syn::PathArguments;
use syn::PathSegment;
use syn::ReturnType;
use syn::Signature;
use syn::Type;
use syn::TypePath;
use syn::TypePtr;
use syn::TypeReference;
use syn::TypeSlice;
use syn::TypeTuple;
use crate::Op;
#[derive(Debug)]
pub(crate) enum BailoutReason {
// Recoverable errors
MustBeSingleSegment,
FastUnsupportedParamType,
}
#[derive(Debug, PartialEq)]
enum StringType {
Cow,
Ref,
Owned,
}
#[derive(Debug, PartialEq)]
enum TransformKind {
// serde_v8::Value
V8Value,
SliceU32(bool),
SliceU8(bool),
SliceF64(bool),
SeqOneByteString(StringType),
PtrU8,
PtrVoid,
WasmMemory,
}
impl Transform {
fn serde_v8_value(index: usize) -> Self {
Transform {
kind: TransformKind::V8Value,
index,
}
}
fn slice_u32(index: usize, is_mut: bool) -> Self {
Transform {
kind: TransformKind::SliceU32(is_mut),
index,
}
}
fn slice_u8(index: usize, is_mut: bool) -> Self {
Transform {
kind: TransformKind::SliceU8(is_mut),
index,
}
}
fn slice_f64(index: usize, is_mut: bool) -> Self {
Transform {
kind: TransformKind::SliceF64(is_mut),
index,
}
}
fn seq_one_byte_string(index: usize, is_ref: StringType) -> Self {
Transform {
kind: TransformKind::SeqOneByteString(is_ref),
index,
}
}
fn wasm_memory(index: usize) -> Self {
Transform {
kind: TransformKind::WasmMemory,
index,
}
}
fn u8_ptr(index: usize) -> Self {
Transform {
kind: TransformKind::PtrU8,
index,
}
}
fn void_ptr(index: usize) -> Self {
Transform {
kind: TransformKind::PtrVoid,
index,
}
}
}
#[derive(Debug, PartialEq)]
pub(crate) struct Transform {
kind: TransformKind,
index: usize,
}
impl Transform {
pub(crate) fn apply_for_fast_call(
&self,
core: &TokenStream,
input: &mut FnArg,
) -> Quote {
let (ty, ident) = match input {
FnArg::Typed(PatType {
ref mut ty,
ref pat,
..
}) => {
let ident = match &**pat {
syn::Pat::Ident(ident) => &ident.ident,
_ => unreachable!("error not recovered"),
};
(ty, ident)
}
_ => unreachable!("error not recovered"),
};
match &self.kind {
// serde_v8::Value
TransformKind::V8Value => {
*ty = parse_quote! { #core::v8::Local<v8::Value> };
q!(Vars { var: &ident }, {
let var = serde_v8::Value { v8_value: var };
})
}
// &[u32]
TransformKind::SliceU32(_) => {
*ty =
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u32> };
q!(Vars { var: &ident }, {
// V8 guarantees that ArrayBuffers are always 4-byte aligned
// (seems to be always 8-byte aligned on 64-bit machines)
// but Deno FFI makes it possible to create ArrayBuffers at any
// alignment. Thus this check is needed.
let var = match unsafe { &*var }.get_storage_if_aligned() {
Some(v) => v,
None => {
unsafe { &mut *fast_api_callback_options }.fallback = true;
return Default::default();
}
};
})
}
// &[u8]
TransformKind::SliceU8(_) => {
*ty =
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u8> };
q!(Vars { var: &ident }, {
// SAFETY: U8 slice is always byte-aligned.
let var =
unsafe { (&*var).get_storage_if_aligned().unwrap_unchecked() };
})
}
TransformKind::SliceF64(_) => {
*ty =
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<f64> };
q!(Vars { var: &ident }, {
let var = match unsafe { &*var }.get_storage_if_aligned() {
Some(v) => v,
None => {
unsafe { &mut *fast_api_callback_options }.fallback = true;
return Default::default();
}
};
})
}
// &str
TransformKind::SeqOneByteString(str_ty) => {
*ty = parse_quote! { *const #core::v8::fast_api::FastApiOneByteString };
match str_ty {
StringType::Ref => q!(Vars { var: &ident }, {
let var = match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
Ok(v) => v,
Err(_) => {
unsafe { &mut *fast_api_callback_options }.fallback = true;
return Default::default();
}
};
}),
StringType::Cow => q!(Vars { var: &ident }, {
let var = ::std::borrow::Cow::Borrowed(
match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
Ok(v) => v,
Err(_) => {
unsafe { &mut *fast_api_callback_options }.fallback = true;
return Default::default();
}
},
);
}),
StringType::Owned => q!(Vars { var: &ident }, {
let var = match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
Ok(v) => v.to_owned(),
Err(_) => {
unsafe { &mut *fast_api_callback_options }.fallback = true;
return Default::default();
}
};
}),
}
}
TransformKind::WasmMemory => {
// Note: `ty` is correctly set to __opts by the fast call tier.
// U8 slice is always byte-aligned.
q!(Vars { var: &ident, core }, {
let var = unsafe {
&*(__opts.wasm_memory
as *const core::v8::fast_api::FastApiTypedArray<u8>)
}
.get_storage_if_aligned();
})
}
// *const u8
TransformKind::PtrU8 => {
*ty =
parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u8> };
q!(Vars { var: &ident }, {
// SAFETY: U8 slice is always byte-aligned.
let var =
unsafe { (&*var).get_storage_if_aligned().unwrap_unchecked() }
.as_ptr();
})
}
TransformKind::PtrVoid => {
*ty = parse_quote! { *mut ::std::ffi::c_void };
q!(Vars {}, {})
}
}
}
}
fn get_fast_scalar(s: &str) -> Option<FastValue> {
match s {
"bool" => Some(FastValue::Bool),
"u32" => Some(FastValue::U32),
"i32" => Some(FastValue::I32),
"u64" | "usize" => Some(FastValue::U64),
"i64" | "isize" => Some(FastValue::I64),
"f32" => Some(FastValue::F32),
"f64" => Some(FastValue::F64),
"* const c_void" | "* mut c_void" => Some(FastValue::Pointer),
"ResourceId" => Some(FastValue::U32),
_ => None,
}
}
fn can_return_fast(v: &FastValue) -> bool {
!matches!(
v,
FastValue::U64
| FastValue::I64
| FastValue::Uint8Array
| FastValue::Uint32Array
)
}
#[derive(Debug, PartialEq, Clone)]
pub(crate) enum FastValue {
Void,
Bool,
U32,
I32,
U64,
I64,
F32,
F64,
Pointer,
V8Value,
Uint8Array,
Uint32Array,
Float64Array,
SeqOneByteString,
}
impl FastValue {
pub fn default_value(&self) -> Quote {
match self {
FastValue::Pointer => q!({ ::std::ptr::null_mut() }),
FastValue::Void => q!({}),
_ => q!({ Default::default() }),
}
}
}
impl Default for FastValue {
fn default() -> Self {
Self::Void
}
}
#[derive(Default, PartialEq)]
pub(crate) struct Optimizer {
pub(crate) returns_result: bool,
pub(crate) has_ref_opstate: bool,
pub(crate) has_rc_opstate: bool,
// Do we need an explict FastApiCallbackOptions argument?
pub(crate) has_fast_callback_option: bool,
// Do we depend on FastApiCallbackOptions?
pub(crate) needs_fast_callback_option: bool,
pub(crate) has_wasm_memory: bool,
pub(crate) fast_result: Option<FastValue>,
pub(crate) fast_parameters: Vec<FastValue>,
pub(crate) transforms: BTreeMap<usize, Transform>,
pub(crate) fast_compatible: bool,
pub(crate) is_async: bool,
}
impl Debug for Optimizer {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
writeln!(f, "=== Optimizer Dump ===")?;
writeln!(f, "returns_result: {}", self.returns_result)?;
writeln!(f, "has_ref_opstate: {}", self.has_ref_opstate)?;
writeln!(f, "has_rc_opstate: {}", self.has_rc_opstate)?;
writeln!(
f,
"has_fast_callback_option: {}",
self.has_fast_callback_option
)?;
writeln!(
f,
"needs_fast_callback_option: {}",
self.needs_fast_callback_option
)?;
writeln!(f, "fast_result: {:?}", self.fast_result)?;
writeln!(f, "fast_parameters: {:?}", self.fast_parameters)?;
writeln!(f, "transforms: {:?}", self.transforms)?;
writeln!(f, "is_async: {}", self.is_async)?;
writeln!(f, "fast_compatible: {}", self.fast_compatible)?;
Ok(())
}
}
impl Optimizer {
pub(crate) fn new() -> Self {
Default::default()
}
pub(crate) const fn has_opstate_in_parameters(&self) -> bool {
self.has_ref_opstate || self.has_rc_opstate
}
pub(crate) const fn needs_opstate(&self) -> bool {
self.has_ref_opstate || self.has_rc_opstate || self.returns_result
}
pub(crate) fn analyze(&mut self, op: &mut Op) -> Result<(), BailoutReason> {
// Fast async ops are opt-in as they have a lazy polling behavior.
if op.is_async && !op.attrs.must_be_fast {
self.fast_compatible = false;
return Ok(());
}
if op.attrs.is_v8 {
self.fast_compatible = false;
return Ok(());
}
self.is_async = op.is_async;
self.fast_compatible = true;
// Just assume for now. We will validate later.
self.has_wasm_memory = op.attrs.is_wasm;
let sig = &op.item.sig;
// Analyze return type
match &sig {
Signature {
output: ReturnType::Default,
..
} => self.fast_result = Some(FastValue::default()),
Signature {
output: ReturnType::Type(_, ty),
..
} if !self.is_async => self.analyze_return_type(ty)?,
// No need to error on the return type for async ops, its OK if
// it's not a fast value.
Signature {
output: ReturnType::Type(_, ty),
..
} => {
let _ = self.analyze_return_type(ty);
// Recover.
self.fast_result = None;
self.fast_compatible = true;
}
};
// The reciever, which we don't actually care about.
self.fast_parameters.push(FastValue::V8Value);
if self.is_async {
// The promise ID.
self.fast_parameters.push(FastValue::I32);
}
// Analyze parameters
for (index, param) in sig.inputs.iter().enumerate() {
self.analyze_param_type(index, param)?;
}
// TODO(@littledivy): https://github.com/denoland/deno/issues/17159
if self.returns_result
&& self.fast_parameters.contains(&FastValue::SeqOneByteString)
{
self.fast_compatible = false;
}
Ok(())
}
fn analyze_return_type(&mut self, ty: &Type) -> Result<(), BailoutReason> {
match ty {
Type::Tuple(TypeTuple { elems, .. }) if elems.is_empty() => {
self.fast_result = Some(FastValue::Void);
}
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
let segment = single_segment(segments)?;
match segment {
// Result<T, E>
PathSegment {
ident, arguments, ..
} if ident == "Result" => {
self.returns_result = true;
if let PathArguments::AngleBracketed(
AngleBracketedGenericArguments { args, .. },
) = arguments
{
match args.first() {
Some(GenericArgument::Type(Type::Path(TypePath {
path: Path { segments, .. },
..
}))) => {
let PathSegment { ident, .. } = single_segment(segments)?;
// Is `T` a scalar FastValue?
if let Some(val) = get_fast_scalar(ident.to_string().as_str())
{
if can_return_fast(&val) {
self.fast_result = Some(val);
return Ok(());
}
}
self.fast_compatible = false;
return Err(BailoutReason::FastUnsupportedParamType);
}
Some(GenericArgument::Type(Type::Tuple(TypeTuple {
elems,
..
})))
if elems.is_empty() =>
{
self.fast_result = Some(FastValue::Void);
}
Some(GenericArgument::Type(Type::Ptr(TypePtr {
mutability: Some(_),
elem,
..
}))) => {
match &**elem {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
// Is `T` a c_void?
let segment = single_segment(segments)?;
match segment {
PathSegment { ident, .. } if ident == "c_void" => {
self.fast_result = Some(FastValue::Pointer);
return Ok(());
}
_ => {
return Err(BailoutReason::FastUnsupportedParamType)
}
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
}
// Is `T` a scalar FastValue?
PathSegment { ident, .. } => {
if let Some(val) = get_fast_scalar(ident.to_string().as_str()) {
self.fast_result = Some(val);
return Ok(());
}
self.fast_compatible = false;
return Err(BailoutReason::FastUnsupportedParamType);
}
};
}
Type::Ptr(TypePtr {
mutability: Some(_),
elem,
..
}) => {
match &**elem {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
// Is `T` a c_void?
let segment = single_segment(segments)?;
match segment {
PathSegment { ident, .. } if ident == "c_void" => {
self.fast_result = Some(FastValue::Pointer);
return Ok(());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
};
Ok(())
}
fn analyze_param_type(
&mut self,
index: usize,
arg: &FnArg,
) -> Result<(), BailoutReason> {
match arg {
FnArg::Typed(typed) => match &*typed.ty {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) if segments.len() == 2 => {
match double_segment(segments)? {
// -> serde_v8::Value
[PathSegment { ident: first, .. }, PathSegment { ident: last, .. }]
if first == "serde_v8" && last == "Value" =>
{
self.fast_parameters.push(FastValue::V8Value);
assert!(self
.transforms
.insert(index, Transform::serde_v8_value(index))
.is_none());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
let segment = single_segment(segments)?;
match segment {
// -> Option<T>
PathSegment {
ident, arguments, ..
} if ident == "Option" => {
if let PathArguments::AngleBracketed(
AngleBracketedGenericArguments { args, .. },
) = arguments
{
// -> Option<&mut T>
if let Some(GenericArgument::Type(Type::Reference(
TypeReference { elem, .. },
))) = args.last()
{
if self.has_wasm_memory {
// -> Option<&mut [u8]>
if let Type::Slice(TypeSlice { elem, .. }) = &**elem {
if let Type::Path(TypePath {
path: Path { segments, .. },
..
}) = &**elem
{
let segment = single_segment(segments)?;
match segment {
// Is `T` a u8?
PathSegment { ident, .. } if ident == "u8" => {
assert!(self
.transforms
.insert(index, Transform::wasm_memory(index))
.is_none());
}
_ => {
return Err(BailoutReason::FastUnsupportedParamType)
}
}
}
}
} else if let Type::Path(TypePath {
path: Path { segments, .. },
..
}) = &**elem
{
let segment = single_segment(segments)?;
match segment {
// Is `T` a FastApiCallbackOptions?
PathSegment { ident, .. }
if ident == "FastApiCallbackOptions" =>
{
self.has_fast_callback_option = true;
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
} else {
return Err(BailoutReason::FastUnsupportedParamType);
}
} else {
return Err(BailoutReason::FastUnsupportedParamType);
}
}
}
// -> Rc<T>
PathSegment {
ident, arguments, ..
} if ident == "Rc" => {
if let PathArguments::AngleBracketed(
AngleBracketedGenericArguments { args, .. },
) = arguments
{
match args.last() {
Some(GenericArgument::Type(Type::Path(TypePath {
path: Path { segments, .. },
..
}))) => {
let segment = single_segment(segments)?;
match segment {
// -> Rc<RefCell<T>>
PathSegment {
ident, arguments, ..
} if ident == "RefCell" => {
if let PathArguments::AngleBracketed(
AngleBracketedGenericArguments { args, .. },
) = arguments
{
match args.last() {
// -> Rc<RefCell<OpState>>
Some(GenericArgument::Type(Type::Path(
TypePath {
path: Path { segments, .. },
..
},
))) => {
let segment = single_segment(segments)?;
match segment {
PathSegment { ident, .. }
if ident == "OpState" =>
{
self.has_rc_opstate = true;
}
_ => {
return Err(
BailoutReason::FastUnsupportedParamType,
)
}
}
}
_ => {
return Err(
BailoutReason::FastUnsupportedParamType,
)
}
}
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
}
// Cow<'_, str>
PathSegment {
ident, arguments, ..
} if ident == "Cow" => {
if let PathArguments::AngleBracketed(
AngleBracketedGenericArguments { args, .. },
) = arguments
{
assert_eq!(args.len(), 2);
let ty = &args[1];
match ty {
GenericArgument::Type(Type::Path(TypePath {
path: Path { segments, .. },
..
})) => {
let segment = single_segment(segments)?;
match segment {
PathSegment { ident, .. } if ident == "str" => {
self.needs_fast_callback_option = true;
self.fast_parameters.push(FastValue::SeqOneByteString);
assert!(self
.transforms
.insert(
index,
Transform::seq_one_byte_string(
index,
StringType::Cow
)
)
.is_none());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
}
// Is `T` a fast scalar?
PathSegment { ident, .. } => {
if let Some(val) = get_fast_scalar(ident.to_string().as_str()) {
self.fast_parameters.push(val);
} else if ident == "String" {
self.needs_fast_callback_option = true;
// Is `T` an owned String?
self.fast_parameters.push(FastValue::SeqOneByteString);
assert!(self
.transforms
.insert(
index,
Transform::seq_one_byte_string(index, StringType::Owned)
)
.is_none());
} else {
return Err(BailoutReason::FastUnsupportedParamType);
}
}
};
}
// &mut T
Type::Reference(TypeReference {
elem, mutability, ..
}) => match &**elem {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
let segment = single_segment(segments)?;
match segment {
// Is `T` a OpState?
PathSegment { ident, .. }
if ident == "OpState" && !self.is_async =>
{
self.has_ref_opstate = true;
}
// Is `T` a str?
PathSegment { ident, .. } if ident == "str" => {
self.needs_fast_callback_option = true;
self.fast_parameters.push(FastValue::SeqOneByteString);
assert!(self
.transforms
.insert(
index,
Transform::seq_one_byte_string(index, StringType::Ref)
)
.is_none());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
// &mut [T]
Type::Slice(TypeSlice { elem, .. }) => match &**elem {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
let segment = single_segment(segments)?;
let is_mut_ref = mutability.is_some();
match segment {
// Is `T` a u8?
PathSegment { ident, .. } if ident == "u8" => {
self.fast_parameters.push(FastValue::Uint8Array);
assert!(self
.transforms
.insert(index, Transform::slice_u8(index, is_mut_ref))
.is_none());
}
// Is `T` a u32?
PathSegment { ident, .. } if ident == "u32" => {
self.needs_fast_callback_option = true;
self.fast_parameters.push(FastValue::Uint32Array);
assert!(self
.transforms
.insert(index, Transform::slice_u32(index, is_mut_ref))
.is_none());
}
// Is `T` a f64?
PathSegment { ident, .. } if ident == "f64" => {
self.needs_fast_callback_option = true;
self.fast_parameters.push(FastValue::Float64Array);
assert!(self
.transforms
.insert(index, Transform::slice_f64(index, is_mut_ref))
.is_none());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
},
_ => return Err(BailoutReason::FastUnsupportedParamType),
},
// *const T
Type::Ptr(TypePtr {
elem,
const_token: Some(_),
..
}) => match &**elem {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
let segment = single_segment(segments)?;
match segment {
// Is `T` a u8?
PathSegment { ident, .. } if ident == "u8" => {
self.fast_parameters.push(FastValue::Uint8Array);
assert!(self
.transforms
.insert(index, Transform::u8_ptr(index))
.is_none());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
},
// *const T
Type::Ptr(TypePtr {
elem,
mutability: Some(_),
..
}) => match &**elem {
Type::Path(TypePath {
path: Path { segments, .. },
..
}) => {
let segment = single_segment(segments)?;
match segment {
// Is `T` a c_void?
PathSegment { ident, .. } if ident == "c_void" => {
self.fast_parameters.push(FastValue::Pointer);
assert!(self
.transforms
.insert(index, Transform::void_ptr(index))
.is_none());
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
}
}
_ => return Err(BailoutReason::FastUnsupportedParamType),
},
_ => return Err(BailoutReason::FastUnsupportedParamType),
},
_ => return Err(BailoutReason::FastUnsupportedParamType),
};
Ok(())
}
}
fn single_segment(
segments: &Punctuated<PathSegment, Colon2>,
) -> Result<&PathSegment, BailoutReason> {
if segments.len() != 1 {
return Err(BailoutReason::MustBeSingleSegment);
}
match segments.last() {
Some(segment) => Ok(segment),
None => Err(BailoutReason::MustBeSingleSegment),
}
}
fn double_segment(
segments: &Punctuated<PathSegment, Colon2>,
) -> Result<[&PathSegment; 2], BailoutReason> {
match (segments.first(), segments.last()) {
(Some(first), Some(last)) => Ok([first, last]),
// Caller ensures that there are only two segments.
_ => unreachable!(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Attributes;
use crate::Op;
use pretty_assertions::assert_eq;
use std::path::PathBuf;
use syn::parse_quote;
#[test]
fn test_single_segment() {
let segments = parse_quote!(foo);
assert!(single_segment(&segments).is_ok());
let segments = parse_quote!(foo::bar);
assert!(single_segment(&segments).is_err());
}
#[test]
fn test_double_segment() {
let segments = parse_quote!(foo::bar);
assert!(double_segment(&segments).is_ok());
assert_eq!(double_segment(&segments).unwrap()[0].ident, "foo");
assert_eq!(double_segment(&segments).unwrap()[1].ident, "bar");
}
#[testing_macros::fixture("optimizer_tests/**/*.rs")]
fn test_analyzer(input: PathBuf) {
let update_expected = std::env::var("UPDATE_EXPECTED").is_ok();
let source =
std::fs::read_to_string(&input).expect("Failed to read test file");
let expected = std::fs::read_to_string(input.with_extension("expected"))
.expect("Failed to read expected file");
let mut attrs = Attributes::default();
if source.contains("// @test-attr:wasm") {
attrs.must_be_fast = true;
attrs.is_wasm = true;
}
if source.contains("// @test-attr:fast") {
attrs.must_be_fast = true;
}
let item = syn::parse_str(&source).expect("Failed to parse test file");
let mut op = Op::new(item, attrs);
let mut optimizer = Optimizer::new();
if let Err(e) = optimizer.analyze(&mut op) {
let e_str = format!("{e:?}");
if update_expected {
std::fs::write(input.with_extension("expected"), e_str)
.expect("Failed to write expected file");
} else {
assert_eq!(e_str, expected);
}
return;
}
if update_expected {
std::fs::write(
input.with_extension("expected"),
format!("{optimizer:#?}"),
)
.expect("Failed to write expected file");
} else {
assert_eq!(format!("{optimizer:#?}"), expected);
}
}
}