Sindbad~EG File Manager
use crate::algorithm::Printer;
use crate::iter::IterDelimited;
use crate::path::PathKind;
use crate::INDENT;
use proc_macro2::TokenStream;
use syn::{
Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro, ForeignItemStatic,
ForeignItemType, ImplItem, ImplItemConst, ImplItemFn, ImplItemMacro, ImplItemType, Item,
ItemConst, ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMod,
ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Receiver,
Signature, StaticMutability, TraitItem, TraitItemConst, TraitItemFn, TraitItemMacro,
TraitItemType, Type, UseGlob, UseGroup, UseName, UsePath, UseRename, UseTree, Variadic,
};
impl Printer {
pub fn item(&mut self, item: &Item) {
match item {
Item::Const(item) => self.item_const(item),
Item::Enum(item) => self.item_enum(item),
Item::ExternCrate(item) => self.item_extern_crate(item),
Item::Fn(item) => self.item_fn(item),
Item::ForeignMod(item) => self.item_foreign_mod(item),
Item::Impl(item) => self.item_impl(item),
Item::Macro(item) => self.item_macro(item),
Item::Mod(item) => self.item_mod(item),
Item::Static(item) => self.item_static(item),
Item::Struct(item) => self.item_struct(item),
Item::Trait(item) => self.item_trait(item),
Item::TraitAlias(item) => self.item_trait_alias(item),
Item::Type(item) => self.item_type(item),
Item::Union(item) => self.item_union(item),
Item::Use(item) => self.item_use(item),
Item::Verbatim(item) => self.item_verbatim(item),
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
_ => unimplemented!("unknown Item"),
}
}
fn item_const(&mut self, item: &ItemConst) {
self.outer_attrs(&item.attrs);
self.cbox(0);
self.visibility(&item.vis);
self.word("const ");
self.ident(&item.ident);
self.generics(&item.generics);
self.word(": ");
self.ty(&item.ty);
self.word(" = ");
self.neverbreak();
self.expr(&item.expr);
self.word(";");
self.end();
self.hardbreak();
}
fn item_enum(&mut self, item: &ItemEnum) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
self.word("enum ");
self.ident(&item.ident);
self.generics(&item.generics);
self.where_clause_for_body(&item.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
for variant in &item.variants {
self.variant(variant);
self.word(",");
self.hardbreak();
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn item_extern_crate(&mut self, item: &ItemExternCrate) {
self.outer_attrs(&item.attrs);
self.visibility(&item.vis);
self.word("extern crate ");
self.ident(&item.ident);
if let Some((_as_token, rename)) = &item.rename {
self.word(" as ");
self.ident(rename);
}
self.word(";");
self.hardbreak();
}
fn item_fn(&mut self, item: &ItemFn) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
self.signature(&item.sig);
self.where_clause_for_body(&item.sig.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for stmt in &item.block.stmts {
self.stmt(stmt);
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn item_foreign_mod(&mut self, item: &ItemForeignMod) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
if item.unsafety.is_some() {
self.word("unsafe ");
}
self.abi(&item.abi);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for foreign_item in &item.items {
self.foreign_item(foreign_item);
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn item_impl(&mut self, item: &ItemImpl) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.ibox(-INDENT);
self.cbox(INDENT);
if item.defaultness.is_some() {
self.word("default ");
}
if item.unsafety.is_some() {
self.word("unsafe ");
}
self.word("impl");
self.generics(&item.generics);
self.end();
self.nbsp();
if let Some((negative_polarity, path, _for_token)) = &item.trait_ {
if negative_polarity.is_some() {
self.word("!");
}
self.path(path, PathKind::Type);
self.space();
self.word("for ");
}
self.ty(&item.self_ty);
self.end();
self.where_clause_for_body(&item.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for impl_item in &item.items {
self.impl_item(impl_item);
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn item_macro(&mut self, item: &ItemMacro) {
self.outer_attrs(&item.attrs);
self.mac(&item.mac, item.ident.as_ref());
self.mac_semi_if_needed(&item.mac.delimiter);
self.hardbreak();
}
fn item_mod(&mut self, item: &ItemMod) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
if item.unsafety.is_some() {
self.word("unsafe ");
}
self.word("mod ");
self.ident(&item.ident);
if let Some((_brace, items)) = &item.content {
self.word(" {");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for item in items {
self.item(item);
}
self.offset(-INDENT);
self.end();
self.word("}");
} else {
self.word(";");
self.end();
}
self.hardbreak();
}
fn item_static(&mut self, item: &ItemStatic) {
self.outer_attrs(&item.attrs);
self.cbox(0);
self.visibility(&item.vis);
self.word("static ");
self.static_mutability(&item.mutability);
self.ident(&item.ident);
self.word(": ");
self.ty(&item.ty);
self.word(" = ");
self.neverbreak();
self.expr(&item.expr);
self.word(";");
self.end();
self.hardbreak();
}
fn item_struct(&mut self, item: &ItemStruct) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
self.word("struct ");
self.ident(&item.ident);
self.generics(&item.generics);
match &item.fields {
Fields::Named(fields) => {
self.where_clause_for_body(&item.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
for field in &fields.named {
self.field(field);
self.word(",");
self.hardbreak();
}
self.offset(-INDENT);
self.end();
self.word("}");
}
Fields::Unnamed(fields) => {
self.fields_unnamed(fields);
self.where_clause_semi(&item.generics.where_clause);
self.end();
}
Fields::Unit => {
self.where_clause_semi(&item.generics.where_clause);
self.end();
}
}
self.hardbreak();
}
fn item_trait(&mut self, item: &ItemTrait) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
if item.unsafety.is_some() {
self.word("unsafe ");
}
if item.auto_token.is_some() {
self.word("auto ");
}
self.word("trait ");
self.ident(&item.ident);
self.generics(&item.generics);
for supertrait in item.supertraits.iter().delimited() {
if supertrait.is_first {
self.word(": ");
} else {
self.word(" + ");
}
self.type_param_bound(&supertrait);
}
self.where_clause_for_body(&item.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for trait_item in &item.items {
self.trait_item(trait_item);
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn item_trait_alias(&mut self, item: &ItemTraitAlias) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
self.word("trait ");
self.ident(&item.ident);
self.generics(&item.generics);
self.word(" = ");
self.neverbreak();
for bound in item.bounds.iter().delimited() {
if !bound.is_first {
self.space();
self.word("+ ");
}
self.type_param_bound(&bound);
}
self.where_clause_semi(&item.generics.where_clause);
self.end();
self.hardbreak();
}
fn item_type(&mut self, item: &ItemType) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
self.word("type ");
self.ident(&item.ident);
self.generics(&item.generics);
self.where_clause_oneline(&item.generics.where_clause);
self.word("= ");
self.neverbreak();
self.ibox(-INDENT);
self.ty(&item.ty);
self.end();
self.word(";");
self.end();
self.hardbreak();
}
fn item_union(&mut self, item: &ItemUnion) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
self.word("union ");
self.ident(&item.ident);
self.generics(&item.generics);
self.where_clause_for_body(&item.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
for field in &item.fields.named {
self.field(field);
self.word(",");
self.hardbreak();
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn item_use(&mut self, item: &ItemUse) {
self.outer_attrs(&item.attrs);
self.visibility(&item.vis);
self.word("use ");
if item.leading_colon.is_some() {
self.word("::");
}
self.use_tree(&item.tree);
self.word(";");
self.hardbreak();
}
#[cfg(not(feature = "verbatim"))]
fn item_verbatim(&mut self, item: &TokenStream) {
if !item.is_empty() {
unimplemented!("Item::Verbatim `{}`", item);
}
self.hardbreak();
}
#[cfg(feature = "verbatim")]
fn item_verbatim(&mut self, tokens: &TokenStream) {
use syn::parse::{Parse, ParseStream, Result};
use syn::punctuated::Punctuated;
use syn::{
braced, parenthesized, token, Attribute, Generics, Ident, Lifetime, Token, Visibility,
};
use verbatim::{
FlexibleItemConst, FlexibleItemFn, FlexibleItemStatic, FlexibleItemType,
WhereClauseLocation,
};
enum ItemVerbatim {
Empty,
ConstFlexible(FlexibleItemConst),
FnFlexible(FlexibleItemFn),
ImplFlexible(ImplFlexible),
Macro2(Macro2),
StaticFlexible(FlexibleItemStatic),
TypeFlexible(FlexibleItemType),
UseBrace(UseBrace),
}
struct ImplFlexible {
attrs: Vec<Attribute>,
vis: Visibility,
defaultness: bool,
unsafety: bool,
generics: Generics,
constness: ImplConstness,
negative_impl: bool,
trait_: Option<Type>,
self_ty: Type,
items: Vec<ImplItem>,
}
enum ImplConstness {
None,
MaybeConst,
Const,
}
struct Macro2 {
attrs: Vec<Attribute>,
vis: Visibility,
ident: Ident,
args: Option<TokenStream>,
body: TokenStream,
}
struct UseBrace {
attrs: Vec<Attribute>,
vis: Visibility,
trees: Punctuated<RootUseTree, Token![,]>,
}
struct RootUseTree {
leading_colon: Option<Token![::]>,
inner: UseTree,
}
impl Parse for ImplConstness {
fn parse(input: ParseStream) -> Result<Self> {
if input.parse::<Option<Token![?]>>()?.is_some() {
input.parse::<Token![const]>()?;
Ok(ImplConstness::MaybeConst)
} else if input.parse::<Option<Token![const]>>()?.is_some() {
Ok(ImplConstness::Const)
} else {
Ok(ImplConstness::None)
}
}
}
impl Parse for RootUseTree {
fn parse(input: ParseStream) -> Result<Self> {
Ok(RootUseTree {
leading_colon: input.parse()?,
inner: input.parse()?,
})
}
}
impl Parse for ItemVerbatim {
fn parse(input: ParseStream) -> Result<Self> {
if input.is_empty() {
return Ok(ItemVerbatim::Empty);
}
let mut attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
let lookahead = input.lookahead1();
if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
let defaultness = false;
let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
Ok(ItemVerbatim::ConstFlexible(flexible_item))
} else if input.peek(Token![const])
|| lookahead.peek(Token![async])
|| lookahead.peek(Token![unsafe]) && !input.peek2(Token![impl])
|| lookahead.peek(Token![extern])
|| lookahead.peek(Token![fn])
{
let defaultness = false;
let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
Ok(ItemVerbatim::FnFlexible(flexible_item))
} else if lookahead.peek(Token![default])
|| input.peek(Token![unsafe])
|| lookahead.peek(Token![impl])
{
let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
let unsafety = input.parse::<Option<Token![unsafe]>>()?.is_some();
input.parse::<Token![impl]>()?;
let has_generics = input.peek(Token![<])
&& (input.peek2(Token![>])
|| input.peek2(Token![#])
|| (input.peek2(Ident) || input.peek2(Lifetime))
&& (input.peek3(Token![:])
|| input.peek3(Token![,])
|| input.peek3(Token![>])
|| input.peek3(Token![=]))
|| input.peek2(Token![const]));
let mut generics: Generics = if has_generics {
input.parse()?
} else {
Generics::default()
};
let constness: ImplConstness = input.parse()?;
let negative_impl =
!input.peek2(token::Brace) && input.parse::<Option<Token![!]>>()?.is_some();
let first_ty: Type = input.parse()?;
let (trait_, self_ty) = if input.parse::<Option<Token![for]>>()?.is_some() {
(Some(first_ty), input.parse()?)
} else {
(None, first_ty)
};
generics.where_clause = input.parse()?;
let content;
braced!(content in input);
let inner_attrs = content.call(Attribute::parse_inner)?;
attrs.extend(inner_attrs);
let mut items = Vec::new();
while !content.is_empty() {
items.push(content.parse()?);
}
Ok(ItemVerbatim::ImplFlexible(ImplFlexible {
attrs,
vis,
defaultness,
unsafety,
generics,
constness,
negative_impl,
trait_,
self_ty,
items,
}))
} else if lookahead.peek(Token![macro]) {
input.parse::<Token![macro]>()?;
let ident: Ident = input.parse()?;
let args = if input.peek(token::Paren) {
let paren_content;
parenthesized!(paren_content in input);
Some(paren_content.parse::<TokenStream>()?)
} else {
None
};
let brace_content;
braced!(brace_content in input);
let body: TokenStream = brace_content.parse()?;
Ok(ItemVerbatim::Macro2(Macro2 {
attrs,
vis,
ident,
args,
body,
}))
} else if lookahead.peek(Token![static]) {
let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?;
Ok(ItemVerbatim::StaticFlexible(flexible_item))
} else if lookahead.peek(Token![type]) {
let defaultness = false;
let flexible_item = FlexibleItemType::parse(
attrs,
vis,
defaultness,
input,
WhereClauseLocation::BeforeEq,
)?;
Ok(ItemVerbatim::TypeFlexible(flexible_item))
} else if lookahead.peek(Token![use]) {
input.parse::<Token![use]>()?;
let content;
braced!(content in input);
let trees = content.parse_terminated(RootUseTree::parse, Token![,])?;
input.parse::<Token![;]>()?;
Ok(ItemVerbatim::UseBrace(UseBrace { attrs, vis, trees }))
} else {
Err(lookahead.error())
}
}
}
let item: ItemVerbatim = match syn::parse2(tokens.clone()) {
Ok(item) => item,
Err(_) => unimplemented!("Item::Verbatim `{}`", tokens),
};
match item {
ItemVerbatim::Empty => {
self.hardbreak();
}
ItemVerbatim::ConstFlexible(item) => {
self.flexible_item_const(&item);
}
ItemVerbatim::FnFlexible(item) => {
self.flexible_item_fn(&item);
}
ItemVerbatim::ImplFlexible(item) => {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.ibox(-INDENT);
self.cbox(INDENT);
self.visibility(&item.vis);
if item.defaultness {
self.word("default ");
}
if item.unsafety {
self.word("unsafe ");
}
self.word("impl");
self.generics(&item.generics);
self.end();
self.nbsp();
match item.constness {
ImplConstness::None => {}
ImplConstness::MaybeConst => self.word("?const "),
ImplConstness::Const => self.word("const "),
}
if item.negative_impl {
self.word("!");
}
if let Some(trait_) = &item.trait_ {
self.ty(trait_);
self.space();
self.word("for ");
}
self.ty(&item.self_ty);
self.end();
self.where_clause_for_body(&item.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for impl_item in &item.items {
self.impl_item(impl_item);
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
ItemVerbatim::Macro2(item) => {
self.outer_attrs(&item.attrs);
self.visibility(&item.vis);
self.word("macro ");
self.ident(&item.ident);
if let Some(args) = &item.args {
self.word("(");
self.cbox(INDENT);
self.zerobreak();
self.ibox(0);
self.macro_rules_tokens(args.clone(), true);
self.end();
self.zerobreak();
self.offset(-INDENT);
self.end();
self.word(")");
}
self.word(" {");
if !item.body.is_empty() {
self.neverbreak();
self.cbox(INDENT);
self.hardbreak();
self.ibox(0);
self.macro_rules_tokens(item.body.clone(), false);
self.end();
self.hardbreak();
self.offset(-INDENT);
self.end();
}
self.word("}");
self.hardbreak();
}
ItemVerbatim::StaticFlexible(item) => {
self.flexible_item_static(&item);
}
ItemVerbatim::TypeFlexible(item) => {
self.flexible_item_type(&item);
}
ItemVerbatim::UseBrace(item) => {
self.outer_attrs(&item.attrs);
self.visibility(&item.vis);
self.word("use ");
if item.trees.len() == 1 {
self.word("::");
self.use_tree(&item.trees[0].inner);
} else {
self.cbox(INDENT);
self.word("{");
self.zerobreak();
self.ibox(0);
for use_tree in item.trees.iter().delimited() {
if use_tree.leading_colon.is_some() {
self.word("::");
}
self.use_tree(&use_tree.inner);
if !use_tree.is_last {
self.word(",");
let mut use_tree = &use_tree.inner;
while let UseTree::Path(use_path) = use_tree {
use_tree = &use_path.tree;
}
if let UseTree::Group(_) = use_tree {
self.hardbreak();
} else {
self.space();
}
}
}
self.end();
self.trailing_comma(true);
self.offset(-INDENT);
self.word("}");
self.end();
}
self.word(";");
self.hardbreak();
}
}
}
fn use_tree(&mut self, use_tree: &UseTree) {
match use_tree {
UseTree::Path(use_path) => self.use_path(use_path),
UseTree::Name(use_name) => self.use_name(use_name),
UseTree::Rename(use_rename) => self.use_rename(use_rename),
UseTree::Glob(use_glob) => self.use_glob(use_glob),
UseTree::Group(use_group) => self.use_group(use_group),
}
}
fn use_path(&mut self, use_path: &UsePath) {
self.ident(&use_path.ident);
self.word("::");
self.use_tree(&use_path.tree);
}
fn use_name(&mut self, use_name: &UseName) {
self.ident(&use_name.ident);
}
fn use_rename(&mut self, use_rename: &UseRename) {
self.ident(&use_rename.ident);
self.word(" as ");
self.ident(&use_rename.rename);
}
fn use_glob(&mut self, use_glob: &UseGlob) {
let _ = use_glob;
self.word("*");
}
fn use_group(&mut self, use_group: &UseGroup) {
if use_group.items.is_empty() {
self.word("{}");
} else if use_group.items.len() == 1 {
self.use_tree(&use_group.items[0]);
} else {
self.cbox(INDENT);
self.word("{");
self.zerobreak();
self.ibox(0);
for use_tree in use_group.items.iter().delimited() {
self.use_tree(&use_tree);
if !use_tree.is_last {
self.word(",");
let mut use_tree = *use_tree;
while let UseTree::Path(use_path) = use_tree {
use_tree = &use_path.tree;
}
if let UseTree::Group(_) = use_tree {
self.hardbreak();
} else {
self.space();
}
}
}
self.end();
self.trailing_comma(true);
self.offset(-INDENT);
self.word("}");
self.end();
}
}
fn foreign_item(&mut self, foreign_item: &ForeignItem) {
match foreign_item {
ForeignItem::Fn(item) => self.foreign_item_fn(item),
ForeignItem::Static(item) => self.foreign_item_static(item),
ForeignItem::Type(item) => self.foreign_item_type(item),
ForeignItem::Macro(item) => self.foreign_item_macro(item),
ForeignItem::Verbatim(item) => self.foreign_item_verbatim(item),
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
_ => unimplemented!("unknown ForeignItem"),
}
}
fn foreign_item_fn(&mut self, foreign_item: &ForeignItemFn) {
self.outer_attrs(&foreign_item.attrs);
self.cbox(INDENT);
self.visibility(&foreign_item.vis);
self.signature(&foreign_item.sig);
self.where_clause_semi(&foreign_item.sig.generics.where_clause);
self.end();
self.hardbreak();
}
fn foreign_item_static(&mut self, foreign_item: &ForeignItemStatic) {
self.outer_attrs(&foreign_item.attrs);
self.cbox(0);
self.visibility(&foreign_item.vis);
self.word("static ");
self.static_mutability(&foreign_item.mutability);
self.ident(&foreign_item.ident);
self.word(": ");
self.ty(&foreign_item.ty);
self.word(";");
self.end();
self.hardbreak();
}
fn foreign_item_type(&mut self, foreign_item: &ForeignItemType) {
self.outer_attrs(&foreign_item.attrs);
self.cbox(0);
self.visibility(&foreign_item.vis);
self.word("type ");
self.ident(&foreign_item.ident);
self.generics(&foreign_item.generics);
self.word(";");
self.end();
self.hardbreak();
}
fn foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro) {
self.outer_attrs(&foreign_item.attrs);
self.mac(&foreign_item.mac, None);
self.mac_semi_if_needed(&foreign_item.mac.delimiter);
self.hardbreak();
}
#[cfg(not(feature = "verbatim"))]
fn foreign_item_verbatim(&mut self, foreign_item: &TokenStream) {
if !foreign_item.is_empty() {
unimplemented!("ForeignItem::Verbatim `{}`", foreign_item);
}
self.hardbreak();
}
#[cfg(feature = "verbatim")]
fn foreign_item_verbatim(&mut self, tokens: &TokenStream) {
use syn::parse::{Parse, ParseStream, Result};
use syn::{Attribute, Token, Visibility};
use verbatim::{FlexibleItemFn, FlexibleItemStatic, FlexibleItemType, WhereClauseLocation};
enum ForeignItemVerbatim {
Empty,
FnFlexible(FlexibleItemFn),
StaticFlexible(FlexibleItemStatic),
TypeFlexible(FlexibleItemType),
}
impl Parse for ForeignItemVerbatim {
fn parse(input: ParseStream) -> Result<Self> {
if input.is_empty() {
return Ok(ForeignItemVerbatim::Empty);
}
let attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
let defaultness = false;
let lookahead = input.lookahead1();
if lookahead.peek(Token![const])
|| lookahead.peek(Token![async])
|| lookahead.peek(Token![unsafe])
|| lookahead.peek(Token![extern])
|| lookahead.peek(Token![fn])
{
let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
Ok(ForeignItemVerbatim::FnFlexible(flexible_item))
} else if lookahead.peek(Token![static]) {
let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?;
Ok(ForeignItemVerbatim::StaticFlexible(flexible_item))
} else if lookahead.peek(Token![type]) {
let flexible_item = FlexibleItemType::parse(
attrs,
vis,
defaultness,
input,
WhereClauseLocation::Both,
)?;
Ok(ForeignItemVerbatim::TypeFlexible(flexible_item))
} else {
Err(lookahead.error())
}
}
}
let foreign_item: ForeignItemVerbatim = match syn::parse2(tokens.clone()) {
Ok(foreign_item) => foreign_item,
Err(_) => unimplemented!("ForeignItem::Verbatim `{}`", tokens),
};
match foreign_item {
ForeignItemVerbatim::Empty => {
self.hardbreak();
}
ForeignItemVerbatim::FnFlexible(foreign_item) => {
self.flexible_item_fn(&foreign_item);
}
ForeignItemVerbatim::StaticFlexible(foreign_item) => {
self.flexible_item_static(&foreign_item);
}
ForeignItemVerbatim::TypeFlexible(foreign_item) => {
self.flexible_item_type(&foreign_item);
}
}
}
fn trait_item(&mut self, trait_item: &TraitItem) {
match trait_item {
TraitItem::Const(item) => self.trait_item_const(item),
TraitItem::Fn(item) => self.trait_item_fn(item),
TraitItem::Type(item) => self.trait_item_type(item),
TraitItem::Macro(item) => self.trait_item_macro(item),
TraitItem::Verbatim(item) => self.trait_item_verbatim(item),
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
_ => unimplemented!("unknown TraitItem"),
}
}
fn trait_item_const(&mut self, trait_item: &TraitItemConst) {
self.outer_attrs(&trait_item.attrs);
self.cbox(0);
self.word("const ");
self.ident(&trait_item.ident);
self.generics(&trait_item.generics);
self.word(": ");
self.ty(&trait_item.ty);
if let Some((_eq_token, default)) = &trait_item.default {
self.word(" = ");
self.neverbreak();
self.expr(default);
}
self.word(";");
self.end();
self.hardbreak();
}
fn trait_item_fn(&mut self, trait_item: &TraitItemFn) {
self.outer_attrs(&trait_item.attrs);
self.cbox(INDENT);
self.signature(&trait_item.sig);
if let Some(block) = &trait_item.default {
self.where_clause_for_body(&trait_item.sig.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&trait_item.attrs);
for stmt in &block.stmts {
self.stmt(stmt);
}
self.offset(-INDENT);
self.end();
self.word("}");
} else {
self.where_clause_semi(&trait_item.sig.generics.where_clause);
self.end();
}
self.hardbreak();
}
fn trait_item_type(&mut self, trait_item: &TraitItemType) {
self.outer_attrs(&trait_item.attrs);
self.cbox(INDENT);
self.word("type ");
self.ident(&trait_item.ident);
self.generics(&trait_item.generics);
for bound in trait_item.bounds.iter().delimited() {
if bound.is_first {
self.word(": ");
} else {
self.space();
self.word("+ ");
}
self.type_param_bound(&bound);
}
if let Some((_eq_token, default)) = &trait_item.default {
self.word(" = ");
self.neverbreak();
self.ibox(-INDENT);
self.ty(default);
self.end();
}
self.where_clause_oneline_semi(&trait_item.generics.where_clause);
self.end();
self.hardbreak();
}
fn trait_item_macro(&mut self, trait_item: &TraitItemMacro) {
self.outer_attrs(&trait_item.attrs);
self.mac(&trait_item.mac, None);
self.mac_semi_if_needed(&trait_item.mac.delimiter);
self.hardbreak();
}
#[cfg(not(feature = "verbatim"))]
fn trait_item_verbatim(&mut self, trait_item: &TokenStream) {
if !trait_item.is_empty() {
unimplemented!("TraitItem::Verbatim `{}`", trait_item);
}
self.hardbreak();
}
#[cfg(feature = "verbatim")]
fn trait_item_verbatim(&mut self, tokens: &TokenStream) {
use syn::parse::{Parse, ParseStream, Result};
use syn::{Attribute, Token, Visibility};
use verbatim::{FlexibleItemType, WhereClauseLocation};
enum TraitItemVerbatim {
Empty,
TypeFlexible(FlexibleItemType),
PubOrDefault(PubOrDefaultTraitItem),
}
struct PubOrDefaultTraitItem {
attrs: Vec<Attribute>,
vis: Visibility,
defaultness: bool,
trait_item: TraitItem,
}
impl Parse for TraitItemVerbatim {
fn parse(input: ParseStream) -> Result<Self> {
if input.is_empty() {
return Ok(TraitItemVerbatim::Empty);
}
let attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
let lookahead = input.lookahead1();
if lookahead.peek(Token![type]) {
let flexible_item = FlexibleItemType::parse(
attrs,
vis,
defaultness,
input,
WhereClauseLocation::AfterEq,
)?;
Ok(TraitItemVerbatim::TypeFlexible(flexible_item))
} else if (lookahead.peek(Token![const])
|| lookahead.peek(Token![async])
|| lookahead.peek(Token![unsafe])
|| lookahead.peek(Token![extern])
|| lookahead.peek(Token![fn]))
&& (!matches!(vis, Visibility::Inherited) || defaultness)
{
Ok(TraitItemVerbatim::PubOrDefault(PubOrDefaultTraitItem {
attrs,
vis,
defaultness,
trait_item: input.parse()?,
}))
} else {
Err(lookahead.error())
}
}
}
let impl_item: TraitItemVerbatim = match syn::parse2(tokens.clone()) {
Ok(impl_item) => impl_item,
Err(_) => unimplemented!("TraitItem::Verbatim `{}`", tokens),
};
match impl_item {
TraitItemVerbatim::Empty => {
self.hardbreak();
}
TraitItemVerbatim::TypeFlexible(trait_item) => {
self.flexible_item_type(&trait_item);
}
TraitItemVerbatim::PubOrDefault(trait_item) => {
self.outer_attrs(&trait_item.attrs);
self.visibility(&trait_item.vis);
if trait_item.defaultness {
self.word("default ");
}
self.trait_item(&trait_item.trait_item);
}
}
}
fn impl_item(&mut self, impl_item: &ImplItem) {
match impl_item {
ImplItem::Const(item) => self.impl_item_const(item),
ImplItem::Fn(item) => self.impl_item_fn(item),
ImplItem::Type(item) => self.impl_item_type(item),
ImplItem::Macro(item) => self.impl_item_macro(item),
ImplItem::Verbatim(item) => self.impl_item_verbatim(item),
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
_ => unimplemented!("unknown ImplItem"),
}
}
fn impl_item_const(&mut self, impl_item: &ImplItemConst) {
self.outer_attrs(&impl_item.attrs);
self.cbox(0);
self.visibility(&impl_item.vis);
if impl_item.defaultness.is_some() {
self.word("default ");
}
self.word("const ");
self.ident(&impl_item.ident);
self.generics(&impl_item.generics);
self.word(": ");
self.ty(&impl_item.ty);
self.word(" = ");
self.neverbreak();
self.expr(&impl_item.expr);
self.word(";");
self.end();
self.hardbreak();
}
fn impl_item_fn(&mut self, impl_item: &ImplItemFn) {
self.outer_attrs(&impl_item.attrs);
self.cbox(INDENT);
self.visibility(&impl_item.vis);
if impl_item.defaultness.is_some() {
self.word("default ");
}
self.signature(&impl_item.sig);
self.where_clause_for_body(&impl_item.sig.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&impl_item.attrs);
for stmt in &impl_item.block.stmts {
self.stmt(stmt);
}
self.offset(-INDENT);
self.end();
self.word("}");
self.hardbreak();
}
fn impl_item_type(&mut self, impl_item: &ImplItemType) {
self.outer_attrs(&impl_item.attrs);
self.cbox(INDENT);
self.visibility(&impl_item.vis);
if impl_item.defaultness.is_some() {
self.word("default ");
}
self.word("type ");
self.ident(&impl_item.ident);
self.generics(&impl_item.generics);
self.word(" = ");
self.neverbreak();
self.ibox(-INDENT);
self.ty(&impl_item.ty);
self.end();
self.where_clause_oneline_semi(&impl_item.generics.where_clause);
self.end();
self.hardbreak();
}
fn impl_item_macro(&mut self, impl_item: &ImplItemMacro) {
self.outer_attrs(&impl_item.attrs);
self.mac(&impl_item.mac, None);
self.mac_semi_if_needed(&impl_item.mac.delimiter);
self.hardbreak();
}
#[cfg(not(feature = "verbatim"))]
fn impl_item_verbatim(&mut self, impl_item: &TokenStream) {
if !impl_item.is_empty() {
unimplemented!("ImplItem::Verbatim `{}`", impl_item);
}
self.hardbreak();
}
#[cfg(feature = "verbatim")]
fn impl_item_verbatim(&mut self, tokens: &TokenStream) {
use syn::parse::{Parse, ParseStream, Result};
use syn::{Attribute, Ident, Token, Visibility};
use verbatim::{FlexibleItemConst, FlexibleItemFn, FlexibleItemType, WhereClauseLocation};
enum ImplItemVerbatim {
Empty,
ConstFlexible(FlexibleItemConst),
FnFlexible(FlexibleItemFn),
TypeFlexible(FlexibleItemType),
}
impl Parse for ImplItemVerbatim {
fn parse(input: ParseStream) -> Result<Self> {
if input.is_empty() {
return Ok(ImplItemVerbatim::Empty);
}
let attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
let lookahead = input.lookahead1();
if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
Ok(ImplItemVerbatim::ConstFlexible(flexible_item))
} else if input.peek(Token![const])
|| lookahead.peek(Token![async])
|| lookahead.peek(Token![unsafe])
|| lookahead.peek(Token![extern])
|| lookahead.peek(Token![fn])
{
let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
Ok(ImplItemVerbatim::FnFlexible(flexible_item))
} else if lookahead.peek(Token![type]) {
let flexible_item = FlexibleItemType::parse(
attrs,
vis,
defaultness,
input,
WhereClauseLocation::AfterEq,
)?;
Ok(ImplItemVerbatim::TypeFlexible(flexible_item))
} else {
Err(lookahead.error())
}
}
}
let impl_item: ImplItemVerbatim = match syn::parse2(tokens.clone()) {
Ok(impl_item) => impl_item,
Err(_) => unimplemented!("ImplItem::Verbatim `{}`", tokens),
};
match impl_item {
ImplItemVerbatim::Empty => {
self.hardbreak();
}
ImplItemVerbatim::ConstFlexible(impl_item) => {
self.flexible_item_const(&impl_item);
}
ImplItemVerbatim::FnFlexible(impl_item) => {
self.flexible_item_fn(&impl_item);
}
ImplItemVerbatim::TypeFlexible(impl_item) => {
self.flexible_item_type(&impl_item);
}
}
}
fn signature(&mut self, signature: &Signature) {
if signature.constness.is_some() {
self.word("const ");
}
if signature.asyncness.is_some() {
self.word("async ");
}
if signature.unsafety.is_some() {
self.word("unsafe ");
}
if let Some(abi) = &signature.abi {
self.abi(abi);
}
self.word("fn ");
self.ident(&signature.ident);
self.generics(&signature.generics);
self.word("(");
self.neverbreak();
self.cbox(0);
self.zerobreak();
for input in signature.inputs.iter().delimited() {
self.fn_arg(&input);
let is_last = input.is_last && signature.variadic.is_none();
self.trailing_comma(is_last);
}
if let Some(variadic) = &signature.variadic {
self.variadic(variadic);
self.zerobreak();
}
self.offset(-INDENT);
self.end();
self.word(")");
self.cbox(-INDENT);
self.return_type(&signature.output);
self.end();
}
fn fn_arg(&mut self, fn_arg: &FnArg) {
match fn_arg {
FnArg::Receiver(receiver) => self.receiver(receiver),
FnArg::Typed(pat_type) => self.pat_type(pat_type),
}
}
fn receiver(&mut self, receiver: &Receiver) {
self.outer_attrs(&receiver.attrs);
if let Some((_ampersand, lifetime)) = &receiver.reference {
self.word("&");
if let Some(lifetime) = lifetime {
self.lifetime(lifetime);
self.nbsp();
}
}
if receiver.mutability.is_some() {
self.word("mut ");
}
self.word("self");
if receiver.colon_token.is_some() {
self.word(": ");
self.ty(&receiver.ty);
} else {
let consistent = match (&receiver.reference, &receiver.mutability, &*receiver.ty) {
(Some(_), mutability, Type::Reference(ty)) => {
mutability.is_some() == ty.mutability.is_some()
&& match &*ty.elem {
Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self"),
_ => false,
}
}
(None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self"),
_ => false,
};
if !consistent {
self.word(": ");
self.ty(&receiver.ty);
}
}
}
fn variadic(&mut self, variadic: &Variadic) {
self.outer_attrs(&variadic.attrs);
if let Some((pat, _colon)) = &variadic.pat {
self.pat(pat);
self.word(": ");
}
self.word("...");
}
fn static_mutability(&mut self, mutability: &StaticMutability) {
match mutability {
StaticMutability::Mut(_) => self.word("mut "),
StaticMutability::None => {}
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
_ => unimplemented!("unknown StaticMutability"),
}
}
}
#[cfg(feature = "verbatim")]
mod verbatim {
use crate::algorithm::Printer;
use crate::iter::IterDelimited;
use crate::INDENT;
use syn::ext::IdentExt;
use syn::parse::{ParseStream, Result};
use syn::{
braced, token, Attribute, Block, Expr, Generics, Ident, Signature, StaticMutability, Stmt,
Token, Type, TypeParamBound, Visibility, WhereClause,
};
pub struct FlexibleItemConst {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub defaultness: bool,
pub ident: Ident,
pub ty: Type,
}
pub struct FlexibleItemFn {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub defaultness: bool,
pub sig: Signature,
pub body: Option<Vec<Stmt>>,
}
pub struct FlexibleItemStatic {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub mutability: StaticMutability,
pub ident: Ident,
pub ty: Option<Type>,
pub expr: Option<Expr>,
}
pub struct FlexibleItemType {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub defaultness: bool,
pub ident: Ident,
pub generics: Generics,
pub bounds: Vec<TypeParamBound>,
pub definition: Option<Type>,
pub where_clause_after_eq: Option<WhereClause>,
}
pub enum WhereClauseLocation {
// type Ty<T> where T: 'static = T;
BeforeEq,
// type Ty<T> = T where T: 'static;
AfterEq,
// TODO: goes away once the migration period on rust-lang/rust#89122 is over
Both,
}
impl FlexibleItemConst {
pub fn parse(
attrs: Vec<Attribute>,
vis: Visibility,
defaultness: bool,
input: ParseStream,
) -> Result<Self> {
input.parse::<Token![const]>()?;
let ident = input.call(Ident::parse_any)?;
input.parse::<Token![:]>()?;
let ty: Type = input.parse()?;
input.parse::<Token![;]>()?;
Ok(FlexibleItemConst {
attrs,
vis,
defaultness,
ident,
ty,
})
}
}
impl FlexibleItemFn {
pub fn parse(
mut attrs: Vec<Attribute>,
vis: Visibility,
defaultness: bool,
input: ParseStream,
) -> Result<Self> {
let sig: Signature = input.parse()?;
let lookahead = input.lookahead1();
let body = if lookahead.peek(Token![;]) {
input.parse::<Token![;]>()?;
None
} else if lookahead.peek(token::Brace) {
let content;
braced!(content in input);
attrs.extend(content.call(Attribute::parse_inner)?);
Some(content.call(Block::parse_within)?)
} else {
return Err(lookahead.error());
};
Ok(FlexibleItemFn {
attrs,
vis,
defaultness,
sig,
body,
})
}
}
impl FlexibleItemStatic {
pub fn parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self> {
input.parse::<Token![static]>()?;
let mutability: StaticMutability = input.parse()?;
let ident = input.parse()?;
let lookahead = input.lookahead1();
let has_type = lookahead.peek(Token![:]);
let has_expr = lookahead.peek(Token![=]);
if !has_type && !has_expr {
return Err(lookahead.error());
}
let ty: Option<Type> = if has_type {
input.parse::<Token![:]>()?;
input.parse().map(Some)?
} else {
None
};
let expr: Option<Expr> = if input.parse::<Option<Token![=]>>()?.is_some() {
input.parse().map(Some)?
} else {
None
};
input.parse::<Token![;]>()?;
Ok(FlexibleItemStatic {
attrs,
vis,
mutability,
ident,
ty,
expr,
})
}
}
impl FlexibleItemType {
pub fn parse(
attrs: Vec<Attribute>,
vis: Visibility,
defaultness: bool,
input: ParseStream,
where_clause_location: WhereClauseLocation,
) -> Result<Self> {
input.parse::<Token![type]>()?;
let ident: Ident = input.parse()?;
let mut generics: Generics = input.parse()?;
let mut bounds = Vec::new();
if input.parse::<Option<Token![:]>>()?.is_some() {
loop {
if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
break;
}
bounds.push(input.parse::<TypeParamBound>()?);
if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
break;
}
input.parse::<Token![+]>()?;
}
}
match where_clause_location {
WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => {
generics.where_clause = input.parse()?;
}
WhereClauseLocation::AfterEq => {}
}
let definition = if input.parse::<Option<Token![=]>>()?.is_some() {
Some(input.parse()?)
} else {
None
};
let where_clause_after_eq = match where_clause_location {
WhereClauseLocation::AfterEq | WhereClauseLocation::Both
if generics.where_clause.is_none() =>
{
input.parse()?
}
_ => None,
};
input.parse::<Token![;]>()?;
Ok(FlexibleItemType {
attrs,
vis,
defaultness,
ident,
generics,
bounds,
definition,
where_clause_after_eq,
})
}
}
impl Printer {
pub fn flexible_item_const(&mut self, item: &FlexibleItemConst) {
self.outer_attrs(&item.attrs);
self.cbox(0);
self.visibility(&item.vis);
if item.defaultness {
self.word("default ");
}
self.word("const ");
self.ident(&item.ident);
self.word(": ");
self.ty(&item.ty);
self.word(";");
self.end();
self.hardbreak();
}
pub fn flexible_item_fn(&mut self, item: &FlexibleItemFn) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
if item.defaultness {
self.word("default ");
}
self.signature(&item.sig);
if let Some(body) = &item.body {
self.where_clause_for_body(&item.sig.generics.where_clause);
self.word("{");
self.hardbreak_if_nonempty();
self.inner_attrs(&item.attrs);
for stmt in body {
self.stmt(stmt);
}
self.offset(-INDENT);
self.end();
self.word("}");
} else {
self.where_clause_semi(&item.sig.generics.where_clause);
self.end();
}
self.hardbreak();
}
pub fn flexible_item_static(&mut self, item: &FlexibleItemStatic) {
self.outer_attrs(&item.attrs);
self.cbox(0);
self.visibility(&item.vis);
self.word("static ");
self.static_mutability(&item.mutability);
self.ident(&item.ident);
if let Some(ty) = &item.ty {
self.word(": ");
self.ty(ty);
}
if let Some(expr) = &item.expr {
self.word(" = ");
self.neverbreak();
self.expr(expr);
}
self.word(";");
self.end();
self.hardbreak();
}
pub fn flexible_item_type(&mut self, item: &FlexibleItemType) {
self.outer_attrs(&item.attrs);
self.cbox(INDENT);
self.visibility(&item.vis);
if item.defaultness {
self.word("default ");
}
self.word("type ");
self.ident(&item.ident);
self.generics(&item.generics);
for bound in item.bounds.iter().delimited() {
if bound.is_first {
self.word(": ");
} else {
self.space();
self.word("+ ");
}
self.type_param_bound(&bound);
}
if let Some(definition) = &item.definition {
self.where_clause_oneline(&item.generics.where_clause);
self.word("= ");
self.neverbreak();
self.ibox(-INDENT);
self.ty(definition);
self.end();
self.where_clause_oneline_semi(&item.where_clause_after_eq);
} else {
self.where_clause_oneline_semi(&item.generics.where_clause);
}
self.end();
self.hardbreak();
}
}
}
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists