src/vendor/syn-0.12.15/src/gen_helper.rs

   1 // Copyright 2018 Syn Developers
   2 //
   3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   6 // option. This file may not be copied, modified, or distributed
   7 // except according to those terms.
   8
   9 #[cfg(feature = "fold")]
  10 pub mod fold {
  11     use punctuated::{Pair, Punctuated};
  12     use fold::Fold;
  13     use proc_macro2::Span;
  14
  15     pub trait FoldHelper {
  16         type Item;
  17         fn lift<F>(self, f: F) -> Self
  18         where
  19             F: FnMut(Self::Item) -> Self::Item;
  20     }
  21
  22     impl<T> FoldHelper for Vec<T> {
  23         type Item = T;
  24         fn lift<F>(self, f: F) -> Self
  25         where
  26             F: FnMut(Self::Item) -> Self::Item,
  27         {
  28             self.into_iter().map(f).collect()
  29         }
  30     }
  31
  32     impl<T, U> FoldHelper for Punctuated<T, U> {
  33         type Item = T;
  34         fn lift<F>(self, mut f: F) -> Self
  35         where
  36             F: FnMut(Self::Item) -> Self::Item,
  37         {
  38             self.into_pairs()
  39                 .map(Pair::into_tuple)
  40                 .map(|(t, u)| Pair::new(f(t), u))
  41                 .collect()
  42         }
  43     }
  44
  45     pub fn tokens_helper<F: Fold + ?Sized, S: Spans>(folder: &mut F, spans: &S) -> S {
  46         spans.fold(folder)
  47     }
  48
  49     pub trait Spans {
  50         fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self;
  51     }
  52
  53     impl Spans for Span {
  54         fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
  55             folder.fold_span(*self)
  56         }
  57     }
  58
  59     impl Spans for [Span; 1] {
  60         fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
  61             [folder.fold_span(self[0])]
  62         }
  63     }
  64
  65     impl Spans for [Span; 2] {
  66         fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
  67             [folder.fold_span(self[0]), folder.fold_span(self[1])]
  68         }
  69     }
  70
  71     impl Spans for [Span; 3] {
  72         fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
  73             [
  74                 folder.fold_span(self[0]),
  75                 folder.fold_span(self[1]),
  76                 folder.fold_span(self[2]),
  77             ]
  78         }
  79     }
  80 }
  81
  82 #[cfg(feature = "visit")]
  83 pub mod visit {
  84     use proc_macro2::Span;
  85     use visit::Visit;
  86
  87     pub fn tokens_helper<'ast, V: Visit<'ast> + ?Sized, S: Spans>(
  88         visitor: &mut V,
  89         spans: &'ast S,
  90     ) {
  91         spans.visit(visitor);
  92     }
  93
  94     pub trait Spans {
  95         fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V);
  96     }
  97
  98     impl Spans for Span {
  99         fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
 100             visitor.visit_span(self);
 101         }
 102     }
 103
 104     impl Spans for [Span; 1] {
 105         fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
 106             visitor.visit_span(&self[0]);
 107         }
 108     }
 109
 110     impl Spans for [Span; 2] {
 111         fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
 112             visitor.visit_span(&self[0]);
 113             visitor.visit_span(&self[1]);
 114         }
 115     }
 116
 117     impl Spans for [Span; 3] {
 118         fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
 119             visitor.visit_span(&self[0]);
 120             visitor.visit_span(&self[1]);
 121             visitor.visit_span(&self[2]);
 122         }
 123     }
 124 }
 125
 126 #[cfg(feature = "visit-mut")]
 127 pub mod visit_mut {
 128     use proc_macro2::Span;
 129     use visit_mut::VisitMut;
 130
 131     pub fn tokens_helper<V: VisitMut + ?Sized, S: Spans>(visitor: &mut V, spans: &mut S) {
 132         spans.visit_mut(visitor);
 133     }
 134
 135     pub trait Spans {
 136         fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V);
 137     }
 138
 139     impl Spans for Span {
 140         fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
 141             visitor.visit_span_mut(self);
 142         }
 143     }
 144
 145     impl Spans for [Span; 1] {
 146         fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
 147             visitor.visit_span_mut(&mut self[0]);
 148         }
 149     }
 150
 151     impl Spans for [Span; 2] {
 152         fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
 153             visitor.visit_span_mut(&mut self[0]);
 154             visitor.visit_span_mut(&mut self[1]);
 155         }
 156     }
 157
 158     impl Spans for [Span; 3] {
 159         fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
 160             visitor.visit_span_mut(&mut self[0]);
 161             visitor.visit_span_mut(&mut self[1]);
 162             visitor.visit_span_mut(&mut self[2]);
 163         }
 164     }
 165 }