Remove Type::Slice from syntax tree
Slices were considered illegal in most positions except as the target of
a reference, which led to confusing code in the code generators. This
commit replaces their syntax tree representation from
Type::Ref(Type::Slice(...)) to Type::SliceRef(...).
diff --git a/syntax/parse.rs b/syntax/parse.rs
index 018e71a..71da158 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -4,8 +4,8 @@
use crate::syntax::Atom::*;
use crate::syntax::{
attrs, error, Api, Array, Doc, Enum, ExternFn, ExternType, Impl, Include, IncludeKind, Lang,
- Namespace, Pair, Receiver, Ref, ResolvableName, Signature, Slice, Struct, Ty1, Type, TypeAlias,
- Var, Variant,
+ Namespace, Pair, Receiver, Ref, ResolvableName, Signature, SliceRef, Struct, Ty1, Type,
+ TypeAlias, Var, Variant,
};
use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
use quote::{format_ident, quote, quote_spanned};
@@ -15,7 +15,7 @@
Abi, Attribute, Error, Expr, Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemType,
GenericArgument, GenericParam, Generics, Ident, ItemEnum, ItemImpl, ItemStruct, Lit, LitStr,
Pat, PathArguments, Result, ReturnType, Token, Type as RustType, TypeArray, TypeBareFn,
- TypePath, TypeReference, TypeSlice,
+ TypePath, TypeReference,
};
pub mod kw {
@@ -640,7 +640,6 @@
match ty {
RustType::Reference(ty) => parse_type_reference(ty),
RustType::Path(ty) => parse_type_path(ty),
- RustType::Slice(ty) => parse_type_slice(ty),
RustType::Array(ty) => parse_type_array(ty),
RustType::BareFn(ty) => parse_type_fn(ty),
RustType::Tuple(ty) if ty.elems.is_empty() => Ok(Type::Void(ty.paren_token.span)),
@@ -649,6 +648,24 @@
}
fn parse_type_reference(ty: &TypeReference) -> Result<Type> {
+ if let RustType::Slice(slice) = ty.elem.as_ref() {
+ let inner = parse_type(&slice.elem)?;
+ return match &inner {
+ Type::Ident(ident) if ident.rust == U8 => Ok(Type::SliceRefU8(Box::new(SliceRef {
+ ampersand: ty.and_token,
+ lifetime: ty.lifetime.clone(),
+ mutable: ty.mutability.is_some(),
+ bracket: slice.bracket_token,
+ inner,
+ mutability: ty.mutability,
+ }))),
+ _ => Err(Error::new_spanned(
+ ty,
+ "only &[u8] and &mut [u8] are supported so far, not other slice types",
+ )),
+ };
+ }
+
let inner = parse_type(&ty.elem)?;
let which = match &inner {
Type::Ident(ident) if ident.rust == "str" => {
@@ -658,10 +675,6 @@
Type::Str
}
}
- Type::Slice(slice) => match &slice.inner {
- Type::Ident(ident) if ident.rust == U8 => Type::SliceRefU8,
- _ => Type::Ref,
- },
_ => Type::Ref,
};
Ok(which(Box::new(Ref {
@@ -742,14 +755,6 @@
Err(Error::new_spanned(ty, "unsupported type"))
}
-fn parse_type_slice(ty: &TypeSlice) -> Result<Type> {
- let inner = parse_type(&ty.elem)?;
- Ok(Type::Slice(Box::new(Slice {
- bracket: ty.bracket_token,
- inner,
- })))
-}
-
fn parse_type_array(ty: &TypeArray) -> Result<Type> {
let inner = parse_type(&ty.elem)?;